kiro 0.1.0

CLI and Desktop application for smart URL routing
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

use clap::{Parser, Subcommand};
use console::style;
use dialoguer::{Select, theme::ColorfulTheme};
use kiro::{App, Result};

/// Kiro
#[derive(Parser, Debug)]
#[command(version, author, about, long_about = None)]
#[command(next_line_help = true)]
struct Args {
    #[command(subcommand)]
    command: Commands,

    #[command(flatten)]
    verbose: clap_verbosity::Verbosity<clap_verbosity::WarnLevel>,
}

#[derive(Subcommand, Debug)]
enum Commands {
    /// Lists all applications that can handle a given URL scheme.
    List {
        /// The URL to query (conflicts with --scheme).
        #[arg(
            short,
            long,
            conflicts_with("scheme"),
            required_unless_present("scheme")
        )]
        url: Option<url::Url>,

        /// The URL scheme to query (conflicts with --url).
        #[arg(short, long, conflicts_with("url"), required_unless_present("url"))]
        scheme: Option<String>,

        /// Paths to search for desktop entries.
        #[arg(long, default_value = None)]
        search_paths: Option<Vec<std::path::PathBuf>>,
    },

    /// Opens the given URL with one of its associated applications.
    Open {
        /// The URL to open.
        url: url::Url,

        /// Paths to search for desktop entries.
        #[arg(long, default_value = None)]
        search_paths: Option<Vec<std::path::PathBuf>>,
    },
}

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

    pretty_env_logger::formatted_builder()
        .filter_level(args.verbose.log_level_filter())
        .init();

    match args.command {
        Commands::List {
            url,
            scheme,
            search_paths,
        } => {
            let scheme = match (url, scheme) {
                (Some(url), _) => url.scheme().to_string(),
                (_, Some(scheme)) => scheme,
                _ => unreachable!(),
            };

            let apps = App::handlers_for_scheme(&scheme, None, search_paths)?;
            println!(
                "{: <16} {}",
                style("App ID").bold().green(),
                style("Name").bold().green()
            );
            for app in apps {
                println!("{:<16} {}", app.appid, app.name);
            }
        }

        Commands::Open { url, search_paths } => {
            let apps = App::handlers_for_scheme(url.scheme(), None, search_paths)?;
            let app_names: Vec<String> = apps
                .iter()
                .map(|app| format!("{:<16} {}", app.appid, app.name))
                .collect();

            let selection = Select::with_theme(&ColorfulTheme::default())
                .with_prompt("Select an application to open the URL with")
                .report(false)
                // TODO: save the last used app as default
                .default(0)
                .items(&app_names)
                .interact_opt()
                .unwrap();

            if let Some(selection) = selection {
                println!(
                    "Opening URL with {}...",
                    style(&apps[selection].name).bold().green()
                );
                apps[selection].open_url(url)?;
            }
        }
    }

    Ok(())
}