unfurl 0.1.0

A tool for expanding links in text
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

use std::path;
use std::collections::BTreeMap;

#[derive(Debug, PartialEq)]
pub struct Match {
  pub vars: BTreeMap<String, String>,
}

impl Match {
  pub fn get<'a>(&'a self, name: &str) -> Option<&'a String> {
    self.vars.get(name)
  }
}

#[derive(Debug, PartialEq)]
pub struct Pattern (path::PathBuf);

impl Pattern {
  pub fn new<P: AsRef<path::Path>>(p: P) -> Pattern {
    Pattern(p.as_ref().to_path_buf())
  }

  pub fn match_path<P: AsRef<path::Path>>(&self, p: P) -> Option<Match> {
    let mut lit = self.0.components().into_iter();
    let mut rit = p.as_ref().components().into_iter();

    let mut vars: BTreeMap<String, String> = BTreeMap::new();
    loop {
      let lc = match lit.next(){
        Some(lc) => lc,
        None     => break,
      };
      let rc = match rit.next(){
        Some(rc) => rc,
        None     => break,
      };
      let lc = match lc {
        path::Component::RootDir   => if lc != rc { return None; } else { continue; },
        path::Component::CurDir    => if lc != rc { return None; } else { continue; },
        path::Component::ParentDir => if lc != rc { return None; } else { continue; },
        path::Component::Normal(v) => match v.to_str() {
          Some(v) => v,
          None    => return None,
        },
        _ => return None,
      };
      let rc = match rc {
        path::Component::Normal(v) => match v.to_str() {
          Some(v) => v,
          None    => return None,
        },
        _ => return None,
      };
      let ln = lc.len();
      if ln > 2 && &lc[0..1] == "{" && &lc[ln-1..ln] == "}" {
        vars.insert(lc[1..ln-1].to_string(), rc.to_string());
      }else if lc != rc {
        return None; // match failed
      }
    }
    
    if let Some(_) = lit.next() {
      return None; // not fully consumed
    };
    if let Some(_) = rit.next() {
      return None; // not fully consumed
    };

    Some(Match{
      vars: vars,
    })
  }
}

#[cfg(test)]
mod tests {
  use super::*;
  
  impl Match {
    fn new(vars: BTreeMap<String, String>) -> Match {
      Match{
        vars: vars,
      }
    }

    fn new_empty() -> Match {
      Match{
        vars: BTreeMap::new(),
      }
    }
  }

  #[test]
  fn equality() {
    let a = Pattern::new("a/b");
    assert_eq!(a, a);
    let b = Pattern::new("a/b");
    assert_eq!(a, b);
  }

  #[test]
  fn match_path() {
    let p = Pattern::new("a/b");
    assert_eq!(None, p.match_path("a/c"));
    assert_eq!(None, p.match_path("/a/b"));
    assert_eq!(None, p.match_path("/a/b/"));

    let p = Pattern::new("/");
    assert_eq!(Some(Match::new_empty()), p.match_path("/"));
    let p = Pattern::new("a/b");
    assert_eq!(Some(Match::new_empty()), p.match_path("a/b"));
    let p = Pattern::new("/a/b");
    assert_eq!(Some(Match::new_empty()), p.match_path("/a/b"));
    let p = Pattern::new("a/{b}");
    assert_eq!(Some(Match::new(BTreeMap::from([("b".to_string(), "Hello".to_string())]))), p.match_path("a/Hello"));

    let p = Pattern::new("/{a}/{b}");
    assert_eq!(Some(Match::new(BTreeMap::from([
      ("a".to_string(), "Anything".to_string()),
      ("b".to_string(), "Hello".to_string()),
    ]))), p.match_path("/Anything/Hello"));
  }

}