search-cli 0.2.0

Cli program to search for arguments words in the browser.
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

use std::path::PathBuf;

use serde::{Deserialize, Serialize};

pub const CONFIG_FILE: &str = "config.yaml";

pub fn config_dir() -> PathBuf {
    let mut dir = dirs::home_dir().unwrap();
    dir.push(".config");
    dir.push("search");

    dir
}

pub fn config_path() -> PathBuf {
    let mut path = config_dir();
    path.push(CONFIG_FILE);
    path
}

pub fn default_config_file() -> Result<Config, serde_yaml::Error> {
    let yaml = r#"
version: "v1.0"
providers:
  - name: google
    aliases:
      - g
    url: "https://google.com/search?q={{ word | urlencode }}"
  - name: bing
    url: "https://www.bing.com/search?q={{ word | urlencode }}"
  - name: duckduckgo
    aliases:
      - d
    url: "https://duckduckgo.com/?q={{ word | urlencode }}"
"#;

    serde_yaml::from_str(yaml)
}

#[derive(Serialize, Deserialize, Debug, PartialEq, Eq, Hash, Clone)]
pub struct Config {
    pub version: String,
    pub providers: Vec<Provider>,
    pub default: Option<DefaultConfig>,
}

#[derive(Serialize, Deserialize, Debug, PartialEq, Eq, Hash, Clone)]
pub struct DefaultConfig {
    /// The default browser path
    pub browser: Option<String>,
}

#[derive(Serialize, Deserialize, Debug, PartialEq, Eq, Hash, Clone)]
pub struct Provider {
    /// The name of the provider
    pub name: String,
    /// The name aliases
    pub aliases: Option<Vec<String>>,
    /// The URL of the provider
    pub url: String,
    /// Open browser for the provider
    #[serde(default)]
    pub browser: Browser,
}

#[derive(Serialize, Deserialize, Debug, PartialEq, Eq, Hash, Clone)]
#[serde(untagged)]
pub enum Browser {
    /// The default browser
    Default,
    /// The default browser settings
    DefaultConfig,
    /// The browser path
    Browser(String),
}

impl Default for Browser {
    fn default() -> Self {
        Self::Default
    }
}

pub fn find_provider(providers: &[Provider], name: String) -> Option<&Provider> {
    for provider in providers.iter() {
        if provider.name == name {
            return Some(provider);
        }

        if let Some(aliases) = &provider.aliases {
            if aliases.iter().any(|alias| alias == &name) {
                return Some(provider);
            }
        }
    }

    None
}