update

src/main.rs

@@ -5,30 +5,42 @@ mod db;
 mod logging;
 mod scan;
 
-use anyhow::Result;
+use anyhow::{Context, Result};
 use clap::Parser;
-use cli::{AttrCmd, Cli, Commands};
-use glob::glob;
+use glob::Pattern;
 use rusqlite::params;
-use tracing::{error, info};
+use shellexpand;
+use shlex;
+use std::{env, path::PathBuf, process::Command};
+use tracing::{debug, error, info};
+use walkdir::WalkDir;
+
+use cli::{AttrCmd, Cli, Commands};
 
 fn main() -> Result<()> {
+    // Parse CLI and bootstrap logging
+    let args = Cli::parse();
+    if args.verbose {
+        env::set_var("RUST_LOG", "debug");
+    }
     logging::init();
 
-    let args = Cli::parse();
     let cfg = config::Config::load()?;
 
-    // snapshot unless doing an explicit backup / restore
-    if !matches!(args.command, Commands::Backup | Commands::Restore { .. }) {
-        let _ = db::backup(&cfg.db_path);
+    // Backup before any non-init, non-backup/restore command
+    if !matches!(args.command, Commands::Init | Commands::Backup | Commands::Restore { .. }) {
+        match db::backup(&cfg.db_path) {
+            Ok(path) => info!("Pre-command auto-backup created at {}", path.display()),
+            Err(e) => error!("Failed to create pre-command auto-backup: {}", e),
+        }
     }
 
-    // open database (runs migrations / dynamic column adds)
+    // Open (and migrate) the DB
     let mut conn = db::open(&cfg.db_path)?;
 
     match args.command {
         Commands::Init => {
-            info!("database initialised at {}", cfg.db_path.display());
+            info!("Database initialised at {}", cfg.db_path.display());
         }
 
         Commands::Scan { paths } => {
@@ -40,17 +52,22 @@ fn main() -> Result<()> {
             }
         }
 
-        Commands::Tag { pattern, tag_path } => apply_tag(&conn, &pattern, &tag_path)?,
+        Commands::Tag { pattern, tag_path } => {
+            apply_tag(&conn, &pattern, &tag_path)?;
+        }
 
         Commands::Attr { action } => match action {
-            // borrow the Strings so attr_set gets &str
             AttrCmd::Set { pattern, key, value } => {
-                attr_set(&conn, &pattern, &key, &value)?
+                attr_set(&conn, &pattern, &key, &value)?;
+            }
+            AttrCmd::Ls { path } => {
+                attr_ls(&conn, &path)?;
             }
-            AttrCmd::Ls { path } => attr_ls(&conn, &path)?,
         },
 
-        Commands::Search { query, exec } => run_search(&conn, &query, exec)?,
+        Commands::Search { query, exec } => {
+            run_search(&conn, &query, exec)?;
+        }
 
         Commands::Backup => {
             let path = db::backup(&cfg.db_path)?;
@@ -58,118 +75,240 @@ fn main() -> Result<()> {
         }
 
         Commands::Restore { backup_path } => {
-            drop(conn); // close handle
-            db::restore(&backup_path, &cfg.db_path)?;
-            println!("Restored from {}", backup_path.display());
+            drop(conn);
+            db::restore(&backup_path, &cfg.db_path)
+                .with_context(|| format!("Failed to restore DB from {}", backup_path.display()))?;
+            println!("Restored DB file from {}", backup_path.display());
+            db::open(&cfg.db_path)
+                .with_context(|| format!("Could not open restored DB at {}", cfg.db_path.display()))?;
+            info!("Successfully opened and processed restored database.");
         }
     }
 
     Ok(())
 }
 
-/* ─── tagging ────────────────────────────────────────────────────────── */
+/// Apply a hierarchical tag to all files matching the glob pattern.
 fn apply_tag(conn: &rusqlite::Connection, pattern: &str, tag_path: &str) -> Result<()> {
     let tag_id = db::ensure_tag_path(conn, tag_path)?;
+    let expanded = shellexpand::tilde(pattern).into_owned();
+    let pat = Pattern::new(&expanded)
+        .with_context(|| format!("Invalid glob pattern `{}`", expanded))?;
+    let root = determine_scan_root(&expanded);
+
     let mut stmt_file = conn.prepare("SELECT id FROM files WHERE path = ?1")?;
     let mut stmt_insert =
         conn.prepare("INSERT OR IGNORE INTO file_tags(file_id, tag_id) VALUES (?1, ?2)")?;
 
-    for entry in glob(pattern)? {
-        match entry {
-            Ok(path) => {
-                let path_str = path.to_string_lossy();
-                if let Ok(file_id) =
-                    stmt_file.query_row(params![path_str], |row| row.get::<_, i64>(0))
-                {
-                    stmt_insert.execute(params![file_id, tag_id])?;
+    let mut count = 0;
+    for entry in WalkDir::new(&root)
+        .into_iter()
+        .filter_map(Result::ok)
+        .filter(|e| e.file_type().is_file())
+    {
+        let path_str = entry.path().to_string_lossy();
+        debug!("testing path: {}", path_str);
+        if !pat.matches(&path_str) {
+            debug!("  → no match");
+            continue;
+        }
+        debug!("  → matched");
+
+        match stmt_file.query_row(params![path_str.as_ref()], |r| r.get::<_, i64>(0)) {
+            Ok(file_id) => {
+                if stmt_insert.execute(params![file_id, tag_id])? > 0 {
                     info!(file = %path_str, tag = tag_path, "tagged");
+                    count += 1;
                 } else {
-                    error!(file = %path_str, "file not in index – run `marlin scan` first");
+                    debug!(file = %path_str, tag = tag_path, "already tagged");
                 }
             }
-            Err(e) => error!(error = %e, "glob error"),
+            Err(rusqlite::Error::QueryReturnedNoRows) => {
+                error!(file = %path_str, "not indexed – run `marlin scan` first");
+            }
+            Err(e) => {
+                error!(file = %path_str, error = %e, "could not lookup file ID");
+            }
         }
     }
+
+    if count > 0 {
+        info!("Applied tag '{}' to {} file(s).", tag_path, count);
+    } else {
+        info!("No new files were tagged with '{}' (no matches or already tagged).", tag_path);
+    }
     Ok(())
 }
 
-/* ─── attributes ─────────────────────────────────────────────────────── */
-fn attr_set(conn: &rusqlite::Connection, pattern: &str, key: &str, value: &str) -> Result<()> {
-    for entry in glob(pattern)? {
-        match entry {
-            Ok(path) => {
-                let path_str = path.to_string_lossy();
-                let file_id = db::file_id(conn, &path_str)?;
+/// Set a key=value attribute on all files matching the glob pattern.
+fn attr_set(
+    conn: &rusqlite::Connection,
+    pattern: &str,
+    key: &str,
+    value: &str,
+) -> Result<()> {
+    let expanded = shellexpand::tilde(pattern).into_owned();
+    let pat = Pattern::new(&expanded)
+        .with_context(|| format!("Invalid glob pattern `{}`", expanded))?;
+    let root = determine_scan_root(&expanded);
+
+    let mut stmt_file = conn.prepare("SELECT id FROM files WHERE path = ?1")?;
+    let mut count = 0;
+
+    for entry in WalkDir::new(&root)
+        .into_iter()
+        .filter_map(Result::ok)
+        .filter(|e| e.file_type().is_file())
+    {
+        let path_str = entry.path().to_string_lossy();
+        debug!("testing attr path: {}", path_str);
+        if !pat.matches(&path_str) {
+            debug!("  → no match");
+            continue;
+        }
+        debug!("  → matched");
+
+        match stmt_file.query_row(params![path_str.as_ref()], |r| r.get::<_, i64>(0)) {
+            Ok(file_id) => {
                 db::upsert_attr(conn, file_id, key, value)?;
                 info!(file = %path_str, key = key, value = value, "attr set");
+                count += 1;
+            }
+            Err(rusqlite::Error::QueryReturnedNoRows) => {
+                error!(file = %path_str, "not indexed – run `marlin scan` first");
+            }
+            Err(e) => {
+                error!(file = %path_str, error = %e, "could not lookup file ID");
             }
-            Err(e) => error!(error = %e, "glob error"),
         }
     }
+
+    if count > 0 {
+        info!("Attribute '{}: {}' set on {} file(s).", key, value, count);
+    } else {
+        info!("No attributes set (no matches or not indexed).");
+    }
     Ok(())
 }
 
+/// List attributes for a given file path.
 fn attr_ls(conn: &rusqlite::Connection, path: &std::path::Path) -> Result<()> {
     let file_id = db::file_id(conn, &path.to_string_lossy())?;
-    let mut stmt = conn.prepare("SELECT key, value FROM attributes WHERE file_id = ?1")?;
-    let rows = stmt.query_map([file_id], |row| Ok((row.get::<_, String>(0)?, row.get::<_, String>(1)?)))?;
-    for row in rows {
+    let mut stmt = conn.prepare(
+        "SELECT key, value FROM attributes WHERE file_id = ?1 ORDER BY key",
+    )?;
+    for row in stmt.query_map([file_id], |r| Ok((r.get::<_, String>(0)?, r.get::<_, String>(1)?)))? {
         let (k, v) = row?;
         println!("{k} = {v}");
     }
     Ok(())
 }
 
-/* ─── search helpers ─────────────────────────────────────────────────── */
-fn run_search(conn: &rusqlite::Connection, raw: &str, exec: Option<String>) -> Result<()> {
-    let hits = search(conn, raw)?;
-
-    if hits.is_empty() && exec.is_none() {
-        eprintln!("No matches for `{}`", raw);
-        return Ok(());
-    }
-
-    if let Some(cmd_tpl) = exec {
-        for path in hits {
-            let cmd_final = if cmd_tpl.contains("{}") {
-                cmd_tpl.replace("{}", &path)
-            } else {
-                format!("{cmd_tpl} \"{path}\"")
-            };
-            let mut parts = cmd_final.splitn(2, ' ');
-            let prog = parts.next().unwrap();
-            let args = parts.next().unwrap_or("");
-            let status = std::process::Command::new(prog)
-                .args(shlex::split(args).unwrap_or_default())
-                .status()?;
-            if !status.success() {
-                error!(file = %path, "command failed");
-            }
-        }
-    } else {
-        for p in hits {
-            println!("{p}");
+/// Build and run an FTS5 search query, with optional exec.
+fn run_search(conn: &rusqlite::Connection, raw_query: &str, exec: Option<String>) -> Result<()> {
+    let mut fts_query_parts = Vec::new();
+    let parts = shlex::split(raw_query).unwrap_or_else(|| vec![raw_query.to_string()]);
+    for part in parts {
+        if ["AND", "OR", "NOT"].contains(&part.as_str()) {
+            fts_query_parts.push(part);
+        } else if let Some(tag) = part.strip_prefix("tag:") {
+            fts_query_parts.push(format!("tags_text:{}", escape_fts_query_term(tag)));
+        } else if let Some(attr) = part.strip_prefix("attr:") {
+            fts_query_parts.push(format!("attrs_text:{}", escape_fts_query_term(attr)));
+        } else {
+            fts_query_parts.push(escape_fts_query_term(&part));
         }
     }
-    Ok(())
-}
-
-fn search(conn: &rusqlite::Connection, raw: &str) -> Result<Vec<String>> {
-    let q = if raw.split_ascii_whitespace().count() == 1
-        && !raw.contains(&['"', '\'', ':', '*', '(', ')', '~', '+', '-'][..])
-    {
-        format!("{raw}*")
-    } else {
-        raw.to_string()
-    };
+    let fts_expr = fts_query_parts.join(" ");
+    debug!("Constructed FTS MATCH expression: {}", fts_expr);
 
     let mut stmt = conn.prepare(
         r#"
-        SELECT f.path FROM files_fts
-        JOIN files f ON f.rowid = files_fts.rowid
-        WHERE files_fts MATCH ?1
+        SELECT f.path
+          FROM files_fts
+          JOIN files f ON f.rowid = files_fts.rowid
+         WHERE files_fts MATCH ?1
+         ORDER BY rank
         "#,
     )?;
-    let rows = stmt.query_map([&q], |row| row.get::<_, String>(0))?;
-    Ok(rows.filter_map(Result::ok).collect())
+    let hits: Vec<String> = stmt
+        .query_map(params![fts_expr], |row| row.get(0))?
+        .filter_map(Result::ok)
+        .collect();
+
+    if let Some(cmd_tpl) = exec {
+        // Exec-on-hits logic
+        let mut ran_without_placeholder = false;
+        // If no hits and no placeholder, run once
+        if hits.is_empty() && !cmd_tpl.contains("{}") {
+            if let Some(mut parts) = shlex::split(&cmd_tpl) {
+                if !parts.is_empty() {
+                    let prog = parts.remove(0);
+                    let status = Command::new(&prog).args(&parts).status()?;
+                    if !status.success() {
+                        error!(command=%cmd_tpl, code=?status.code(), "command failed");
+                    }
+                }
+            }
+            ran_without_placeholder = true;
+        }
+        // Otherwise, run per hit
+        if !ran_without_placeholder {
+            for path in hits {
+                let quoted = shlex::try_quote(&path).unwrap_or(path.clone().into());
+                let cmd_final = if cmd_tpl.contains("{}") {
+                    cmd_tpl.replace("{}", &quoted)
+                } else {
+                    format!("{} {}", cmd_tpl, &quoted)
+                };
+                if let Some(mut parts) = shlex::split(&cmd_final) {
+                    if parts.is_empty() {
+                        continue;
+                    }
+                    let prog = parts.remove(0);
+                    let status = Command::new(&prog).args(&parts).status()?;
+                    if !status.success() {
+                        error!(file=%path, command=%cmd_final, code=?status.code(), "command failed");
+                    }
+                }
+            }
+        }
+    } else {
+        if hits.is_empty() {
+            eprintln!("No matches for query: `{}` (FTS expression: `{}`)", raw_query, fts_expr);
+        } else {
+            for p in hits {
+                println!("{}", p);
+            }
+        }
+    }
+
+    Ok(())
+}
+
+/// Quote terms for FTS when needed.
+fn escape_fts_query_term(term: &str) -> String {
+    if term.contains(|c: char| c.is_whitespace() || "-:()\"".contains(c))
+        || ["AND","OR","NOT","NEAR"].contains(&term.to_uppercase().as_str())
+    {
+        format!("\"{}\"", term.replace('"', "\"\""))  
+    } else {
+        term.to_string()
+    }
+}
+
+/// Determine a filesystem root to limit recursive walking.
+fn determine_scan_root(pattern: &str) -> PathBuf {
+    let wildcard_pos = pattern.find(|c| c == '*' || c == '?' || c == '[').unwrap_or(pattern.len());
+    let prefix = &pattern[..wildcard_pos];
+    let mut root = PathBuf::from(prefix);
+    while root.as_os_str().to_string_lossy().contains(|c| ['*','?','['].contains(&c)) {
+        if let Some(parent) = root.parent() {
+            root = parent.to_path_buf();
+        } else {
+            root = PathBuf::from(".");
+            break;
+        }
+    }
+    root
 }