ublx 0.2.0

TUI to index once, enrich with metadata, and browse a flat snapshot in a 3-pane layout with multiple modes.
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
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143

//! Live catalog + snapshot job state for one serve process.

use std::path::{Path, PathBuf};
use std::sync::{Arc, Mutex};

use rusqlite::Connection;
use serde::Serialize;

use super::error::ApiError;

/// Live catalog for one serve process — switchable via `/roots/current`.
pub(super) struct ServeCatalog {
    pub(super) dir: PathBuf,
    /// Catalog file actually opened (for duplicate load and reopen).
    pub(super) read_path: PathBuf,
    pub(super) conn: Connection,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize)]
#[serde(rename_all = "lowercase")]
pub(super) enum SnapshotState {
    Idle,
    Running,
    Done,
    Failed,
}

#[derive(Debug, Clone, Serialize)]
pub(super) struct SnapshotLast {
    pub(super) added: usize,
    pub(super) modified: usize,
    pub(super) removed: usize,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub(super) error: Option<String>,
}

#[derive(Debug, Clone, Serialize)]
pub(super) struct SnapshotStatus {
    state: SnapshotState,
    #[serde(skip_serializing_if = "Option::is_none")]
    dir: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    last: Option<SnapshotLast>,
}

pub(super) struct SnapshotJob {
    pub(super) state: SnapshotState,
    pub(super) dir: Option<PathBuf>,
    last: Option<SnapshotLast>,
}

impl SnapshotJob {
    pub(super) fn idle() -> Self {
        Self {
            state: SnapshotState::Idle,
            dir: None,
            last: None,
        }
    }

    pub(super) fn status(&self) -> SnapshotStatus {
        SnapshotStatus {
            state: self.state,
            dir: self.dir.as_ref().map(|p| p.display().to_string()),
            last: self.last.clone(),
        }
    }

    pub(super) fn is_running(&self) -> bool {
        self.state == SnapshotState::Running
    }

    pub(super) fn mark_finished(&mut self, state: SnapshotState, last: SnapshotLast) {
        self.state = state;
        self.last = Some(last);
    }
}

pub(super) struct AppStateInner {
    pub(super) catalog: ServeCatalog,
    pub(super) snapshot: SnapshotJob,
}

pub(super) type AppState = Arc<Mutex<AppStateInner>>;

pub(super) fn with_db<T>(
    state: &AppState,
    f: impl FnOnce(&Connection) -> Result<T, ApiError>,
) -> Result<T, ApiError> {
    with_inner(state, |inner| f(&inner.catalog.conn))
}

pub(super) fn with_inner<T>(
    state: &AppState,
    f: impl FnOnce(&mut AppStateInner) -> Result<T, ApiError>,
) -> Result<T, ApiError> {
    let mut inner = state.lock().map_err(|_| ApiError::lock())?;
    f(&mut inner)
}

pub(super) fn current_dir(state: &AppState) -> Result<PathBuf, ApiError> {
    with_inner(state, |inner| Ok(inner.catalog.dir.clone()))
}

/// Reject mutations while a background snapshot is writing.
pub(super) fn ensure_snapshot_idle(state: &AppState) -> Result<(), ApiError> {
    with_inner(state, |inner| {
        if inner.snapshot.is_running() {
            return Err(ApiError::conflict(
                "snapshot in progress; wait for GET /snapshot to leave running before mutating",
            ));
        }
        Ok(())
    })
}

/// Re-open the catalog connection after an out-of-band DB write (module helpers open their own conn).
pub(super) fn reopen_catalog(state: &AppState) -> Result<(), ApiError> {
    let dir = current_dir(state)?;
    let handle = crate::cli::catalog::open_catalog_for_read(&dir).map_err(ApiError::from)?;
    with_inner(state, |inner| {
        inner.catalog.dir = handle.paths.dir;
        inner.catalog.read_path = handle.read_path;
        inner.catalog.conn = handle.conn;
        Ok(())
    })
}

/// Catalog root + DB path for mutation helpers (`modules::file_ops` / `lenses` / `enhancer`).
pub(super) fn mutation_paths(state: &AppState) -> Result<(PathBuf, PathBuf), ApiError> {
    ensure_snapshot_idle(state)?;
    let dir = current_dir(state)?;
    let db = crate::config::UblxPaths::new(&dir).db();
    Ok((dir, db))
}

pub(super) fn canonicalize_dir(dir: &Path) -> PathBuf {
    dir.canonicalize().unwrap_or_else(|_| dir.to_path_buf())
}

pub(super) fn same_dir(a: &Path, b: &Path) -> bool {
    canonicalize_dir(a) == canonicalize_dir(b)
}