dkdc-bookmarks 0.4.1

Bookmarks in your filesystem
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

use anyhow::{Context, Result};
use clap::Parser;
use std::path::PathBuf;

use bookmarks_core::config::{edit_config, print_config};
use bookmarks_core::open::open_links;
use bookmarks_core::storage::Storage;
use bookmarks_core::toml_storage::TomlStorage;

#[derive(Parser, Debug)]
#[command(name = "bookmarks")]
#[command(about = "Bookmarks in your filesystem")]
#[command(version)]
pub struct Args {
    /// Path to bookmarks file (overrides cwd and global)
    #[arg(short = 'f', long = "bookmarks-file", conflicts_with = "global")]
    pub bookmarks_file: Option<PathBuf>,

    /// Use global config (~/.config/bookmarks/bookmarks.toml), ignore local
    #[arg(short, long, conflicts_with_all = ["bookmarks_file", "local"])]
    pub global: bool,

    /// Use local config (./bookmarks.toml), create if missing
    #[arg(short, long, conflicts_with_all = ["bookmarks_file", "global"])]
    pub local: bool,

    /// Open active bookmarks file in $EDITOR (use -gc for global)
    #[arg(short, long)]
    pub config: bool,

    /// Open the desktop app
    #[cfg(feature = "app")]
    #[arg(short = 'a', long)]
    pub app: bool,

    /// Open the webapp
    #[cfg(feature = "webapp")]
    #[arg(short = 'w', long)]
    pub webapp: bool,

    /// Things to open (url names, aliases, or groups)
    pub urls: Vec<String>,
}

/// Resolve which bookmarks file to use and ensure it exists:
/// 1. --bookmarks-file flag (explicit, must exist)
/// 2. --local flag (cwd, auto-created)
/// 3. --global flag (skip cwd, use global)
/// 4. bookmarks.toml in cwd (local, must exist)
/// 5. ~/.config/bookmarks/bookmarks.toml (global, auto-created)
fn resolve_storage(
    bookmarks_file: Option<PathBuf>,
    global: bool,
    local: bool,
) -> Result<TomlStorage> {
    if let Some(path) = bookmarks_file {
        anyhow::ensure!(
            path.exists(),
            "bookmarks file not found: {}",
            path.display()
        );
        return Ok(TomlStorage::new(path));
    }

    if local {
        let cwd_path = TomlStorage::cwd_path().context("failed to get current directory")?;
        let storage = TomlStorage::new(cwd_path);
        storage.init()?;
        return Ok(storage);
    }

    if !global
        && let Some(cwd_path) = TomlStorage::cwd_path()
        && cwd_path.exists()
    {
        return Ok(TomlStorage::new(cwd_path));
    }

    let storage = TomlStorage::with_default_path()?;
    storage.init()?;
    Ok(storage)
}

pub fn run_cli<I, T>(args: I) -> Result<()>
where
    I: IntoIterator<Item = T>,
    T: Into<std::ffi::OsString> + Clone,
{
    let args = Args::parse_from(args);

    let storage = resolve_storage(args.bookmarks_file, args.global, args.local)?;

    #[cfg(feature = "app")]
    if args.app {
        return bookmarks_app::run_app(Box::new(storage)).map_err(|e| anyhow::anyhow!("{e}"));
    }

    #[cfg(feature = "webapp")]
    if args.webapp {
        return bookmarks_webapp::run_webapp(Box::new(storage));
    }

    if args.config {
        match storage.path() {
            Some(path) => edit_config(path)?,
            None => anyhow::bail!("no bookmarks file found to edit"),
        }
        return Ok(());
    }

    let config = storage.load()?;

    if args.urls.is_empty() {
        print_config(&config);
    } else {
        open_links(&args.urls, &config)?;
    }

    if let Some(path) = storage.path() {
        println!(
            "(using {}, use --bookmarks-file to override)",
            path.display()
        );
    }

    Ok(())
}