xtagger 0.1.0

Command line application for managing and searching tags stored in filesystem extended attributes 
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

use clap::{Parser, Subcommand};
use glob::{glob_with, MatchOptions};
use itertools::Itertools;
use std::collections::HashMap;
use std::error::Error;
use std::path::PathBuf;
use std::str;
use xtag::TaggerError;

#[derive(Parser)]
#[clap(author, version, about, long_about = None)]
struct Args {
    #[clap(subcommand)]
    command: Commands,
}

#[derive(Subcommand)]
enum Commands {
    /// Add tags
    Add {
        /// Comma separated list of tags
        #[clap(value_name = "TAGS")]
        tags: String,

        #[clap(parse(from_os_str), value_name = "GLOB")]
        globs: Vec<PathBuf>,
    },

    /// Remove tags
    Remove {
        /// Comma separated list of tags
        #[clap(value_name = "TAGS")]
        tags: String,

        #[clap(parse(from_os_str), value_name = "GLOB")]
        globs: Vec<PathBuf>,
    },

    /// Delete all tags
    Delete {
        #[clap(parse(from_os_str), value_name = "GLOB")]
        globs: Vec<PathBuf>,
    },

    /// List all tags
    List {
        #[clap(parse(from_os_str), value_name = "GLOB")]
        globs: Vec<PathBuf>,
    },

    /// Find
    Find {
        /// Search term
        #[clap(value_name = "TERM")]
        term: String,

        #[clap(parse(from_os_str), value_name = "GLOB")]
        globs: Vec<PathBuf>,
    },
}

// Adds tags to given file
// FIXME Prints no messages
fn add(path: &PathBuf, tags: &HashMap<String, Option<String>>) -> Result<(), TaggerError> {
    let mut container = xtag::get_tags(&path)?;
    container.extend(tags.clone());
    xtag::set_tags(&path, &container)?;
    Ok(())
}

fn delete(path: &PathBuf, _: &()) -> Result<(), TaggerError> {
    xtag::delete_tags(path)
}

fn list(path: &PathBuf, _: &()) -> Result<(), TaggerError> {
    println!("{}", path.display());
    let container = xtag::get_tags(&path)?;
    for (tag, value) in container.iter().sorted() {
        match value {
            Some(value) => println!("  {}={}", tag, value),
            None => println!("  {}", tag),
        }
    }
    Ok(())
}

fn remove(path: &PathBuf, tags: &HashMap<String, Option<String>>) -> Result<(), TaggerError> {
    let mut container = xtag::get_tags(&path)?;

    for tag in tags.keys() {
        println!("Removing {} from {}", tag, path.display());
        container.remove(tag);
    }
    xtag::set_tags(&path, &container)?;
    Ok(())
}

fn find(path: &PathBuf, term: &String) -> Result<(), TaggerError> {
    if xtag::find_tags(path, term)? {
        println!("{}", path.display());
    }
    Ok(())
}

fn do_for_all<A>(
    globs: &Vec<PathBuf>,
    arg: &A,
    func: fn(&PathBuf, &A) -> Result<(), TaggerError>,
) -> Result<(), Box<dyn Error>> {
    let options = MatchOptions {
        ..Default::default()
    };

    for glob in globs {
        let glob = glob.to_str().ok_or("Could not convert path to string")?;
        let globber = glob_with(glob, options)?;
        for entry in globber {
            func(&entry?, arg)?;
        }
    }
    Ok(())
}

fn main() -> Result<(), Box<dyn Error>> {
    let args = Args::parse();

    match &args.command {
        Commands::Add { tags, globs } => do_for_all(globs, &xtag::string_to_map(tags)?, add),
        Commands::Remove { tags, globs } => do_for_all(globs, &xtag::string_to_map(tags)?, remove),
        Commands::Delete { globs } => do_for_all(globs, &(), delete),
        Commands::List { globs } => do_for_all(globs, &(), list),
        Commands::Find { term, globs } => do_for_all(globs, term, find),
    }
}