link-cli 0.2.6

A CLI tool and reusable library for links manipulation backed by a LiNo-notation doublet storage engine.
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

//! Link CLI - A command-line tool for links manipulation
//!
//! This is the Rust implementation of the link-cli tool, providing
//! similar functionality to the C# version.

use anyhow::Result;
use link_cli::cli::{Cli, CliCommand};
use link_cli::import_lino_file;
use link_cli::{NamedTypeLinks, NamedTypesDecorator, QueryProcessor};

fn main() -> Result<()> {
    let cli = match Cli::parse()? {
        CliCommand::Run(cli) => cli,
        CliCommand::Help => {
            Cli::print_help();
            return Ok(());
        }
        CliCommand::Version => {
            println!("{}", Cli::version_text());
            return Ok(());
        }
    };

    // Create link storage with separate named-type aliases.
    let mut storage = NamedTypesDecorator::new(&cli.db, cli.trace)?;

    // Print before state if requested
    if cli.before {
        storage.print_all_lino()?;
    }

    if let Some(input_path) = &cli.lino_input {
        import_lino_file(&mut storage, input_path)?;
    }

    // If --structure is provided, handle it separately
    if let Some(link_id) = cli.structure {
        let structure_formatted = storage.format_structure(link_id)?;
        println!("{}", structure_formatted);
        if let Some(output_path) = &cli.lino_output {
            storage.write_lino_output(output_path)?;
        }
        return Ok(());
    }

    // Get effective query (option takes precedence over positional argument)
    let effective_query = cli.query.as_deref().or(cli.query_arg.as_deref());

    // Collect changes
    let mut changes_list = Vec::new();

    // Process query if provided
    if let Some(query) = effective_query {
        if !query.is_empty() {
            let processor = QueryProcessor::new(cli.trace)
                .with_auto_create_missing_references(cli.auto_create_missing_references);
            changes_list = processor.process_query(&mut storage, query)?;
        }
    }

    // Print changes if requested
    if cli.changes && !changes_list.is_empty() {
        for (before_link, after_link) in &changes_list {
            storage.print_change_lino(before_link, after_link)?;
        }
    }

    // Print after state if requested
    if cli.after {
        storage.print_all_lino()?;
    }

    if let Some(output_path) = &cli.lino_output {
        storage.write_lino_output(output_path)?;
    }

    Ok(())
}