rustyroad 1.3.0

Rusty Road is a framework written in Rust that is based on Ruby on Rails. It is designed to provide the familiar conventions and ease of use of Ruby on Rails, while also taking advantage of the performance and efficiency of Rust.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

//! Restricts breaking-change scanning to migrations that will actually run.
//!
//! The scanner reads `up.sql` from disk and has no notion of what the target
//! database already contains. Scanning migrations the ledger already records as
//! applied blocks commands that would otherwise be no-ops, so the set of
//! directories is filtered through the ledger first.

use crate::database::migrations::ledger;
use crate::database::{Database, DatabaseConnection};
use std::path::{Path, PathBuf};

/// Returns the subset of `directories` whose migrations are not yet applied.
///
/// When the ledger cannot be consulted the input is returned unchanged, so a
/// database that is unreachable makes the scanner more cautious, never less.
pub(super) async fn unapplied(directories: Vec<PathBuf>) -> Vec<PathBuf> {
    match connect().await {
        Some(connection) => filter(&connection, directories).await,
        None => directories,
    }
}

/// Filters `directories` down to those not recorded as applied in `connection`.
pub(super) async fn filter(
    connection: &DatabaseConnection,
    directories: Vec<PathBuf>,
) -> Vec<PathBuf> {
    let mut pending = Vec::new();
    for directory in directories {
        if is_pending(connection, &directory).await {
            pending.push(directory);
        }
    }
    pending
}

/// Returns `true` when the migration still needs to be applied.
async fn is_pending(connection: &DatabaseConnection, directory: &Path) -> bool {
    let Some(path) = directory.to_str() else {
        return true;
    };
    let Some(id) = ledger::ledger_id_for_dir(path) else {
        return true;
    };

    // Treat a failed lookup as pending so scanning still happens.
    !ledger::is_applied(connection, id).await.unwrap_or(false)
}

/// Opens a ledger connection, returning `None` when unavailable.
async fn connect() -> Option<DatabaseConnection> {
    let database = Database::get_database_from_rustyroad_toml().ok()?;
    let connection = Database::create_database_connection(&database).await.ok()?;
    ledger::ensure_table(&connection).await.ok()?;
    Some(connection)
}