polk 1.1.6

Dotfile manager and symlinker
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
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149

use Error;
use serde;

use std::fmt::{self, Write};
use std::str::FromStr;

/// The full URL to GitHub.
pub const GITHUB_URL: &'static str = "https://github.com";

/// The assumed name of a repository containing dotfiles.
pub const DEFAULT_GIT_REPOSITORY_NAME: &'static str = "dotfiles";

mod spec_matchers {
    use regex::Regex;

    lazy_static! {
        /// GitHub spec
        /// `github:<username>[/repository]`
        pub static ref GITHUB: Regex = Regex::new("github:(\\w+)/?(\\w+)?").unwrap();
    }
}

/// A source of dotfiles.
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum SourceSpec {
    /// A GitHub dotfiles repository.
    GitHub {
        /// The username of the user that owns the dotfiles repository.
        username: String,
        /// The repository name that contains the dotfiles.
        /// If `None`, we will assume that the repository is named `dotfiles`.
        repository: Option<String>,
    },
    /// An arbitrary URL.
    Url(String),
}

/// A source of dotfiles.
#[derive(Clone, Debug)]
pub enum Source {
    Git {
        url: String,
    }
}

impl SourceSpec
{
    /// Gets the canonical source.
    pub fn canonical(&self) -> Source {
        match *self {
            SourceSpec::GitHub { ref username, ref repository } => {
                let repository = repository.as_ref().map(|r| r.to_owned()).
                    unwrap_or(DEFAULT_GIT_REPOSITORY_NAME.to_owned());

                let url = format!("{}/{}/{}.git", GITHUB_URL, username, repository);
                Source::Git { url: url }
            },
            SourceSpec::Url(ref url) => {
                Source::Git { url: url.clone() }
            },
        }
    }

    /// Gets a human readable description of the spec.
    pub fn description(&self) -> String {
        let mut d = String::new();

        match *self {
            SourceSpec::GitHub { ref username, ref repository } => {
                write!(d, "the GitHub repository owned by '{}' ", username).unwrap();

                if let Some(ref repo) = *repository {
                    write!(d, "named '{}'", repo).unwrap();
                } else {
                    write!(d, ", assuming repository named '{}'", DEFAULT_GIT_REPOSITORY_NAME).unwrap();
                }
            },
            SourceSpec::Url(ref url) => {
                write!(d, "the url at {}", url).unwrap();
            },
        }

        d
    }
}

impl fmt::Display for SourceSpec {
    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            SourceSpec::GitHub { ref username, ref repository } => {
                write!(fmt, "github:{}", username)?;

                if let Some(ref repo) = *repository {
                    write!(fmt, "/{}", repo)?;
                }
            },
            SourceSpec::Url(ref url) => {
                write!(fmt, "{}", url)?;
            },
        }

        Ok(())
    }
}

impl FromStr for SourceSpec {
    type Err = Error;

    fn from_str(s: &str) -> Result<Self, Error> {
        if spec_matchers::GITHUB.is_match(s) {
            let captures = spec_matchers::GITHUB.captures(s).unwrap();
            let username = captures.get(1).unwrap().as_str().to_owned();
            let repository = captures.get(2).map(|m| m.as_str().to_owned());

            Ok(SourceSpec::GitHub { username: username, repository: repository })
        } else {
            // Assume URL if nothing else.
            Ok(SourceSpec::Url(s.to_owned()))
        }
    }
}

impl serde::Serialize for SourceSpec {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
        where S: serde::Serializer {
        self.to_string().serialize(serializer)
    }
}

impl<'de> serde::Deserialize<'de> for SourceSpec {
    fn deserialize<S>(deserializer: S) -> Result<Self, S::Error>
        where S: serde::Deserializer<'de> {
        use serde::de::Error;
        let spec_str = String::deserialize(deserializer)?;

        match spec_str.parse() {
            Ok(spec) => Ok(spec),
            Err(e) => Err(S::Error::custom(e.to_string())),
        }

    }
}

impl Into<Source> for SourceSpec {
    fn into(self) -> Source {
        self.canonical()
    }
}