parser doesnt include brackets into source substitution array

diff --git a/src/parser/parse.rs b/src/parser/parse.rs
index b314c400903e26adc2fff60ce8982f4b49ce4145..5af268d6f1511f59d0b3d51571f22468d76d2799 100644 (file)
--- a/src/parser/parse.rs
+++ b/src/parser/parse.rs
@@ -62,12 +62,19 @@ fn parse_array_defs(pairs: Pairs<Rule>) -> HashMap<&'_ str, Vec<&'_ str>> {
 fn parse_source(pairs: Pairs<Rule>) -> Vec<Source> {
     let mut vec: Vec<Source> = Vec::new();
 
+    macro_rules! push_src (
+        (var($s:expr)) => { vec.push(Source::Sub(Substitution::Variable($s))) };
+        (arr($s:expr)) => { vec.push(Source::Sub(Substitution::Array($s))) };
+        (pat($s:expr)) => { vec.push(Source::Sub(Substitution::Pattern($s))) };
+        ($s:expr) => { vec.push(Source::Str($s)) };
+    );
+
     for pair in pairs {
         match pair.as_rule() {
-            Rule::var_sub => vec.push(Source::Sub(Substitution::Variable(pair.as_str()))),
-            Rule::arr_sub => vec.push(Source::Sub(Substitution::Array(pair.as_str()))),
-            Rule::pat_sub => vec.push(Source::Sub(Substitution::Pattern(pair.as_str()))),
-            Rule::char_seq => vec.push(Source::Str(pair.as_str())),
+            Rule::var_sub => push_src!(var(parse_substitution(pair))),
+            Rule::arr_sub => push_src!(arr(parse_substitution(pair))),
+            Rule::pat_sub => push_src!(pat(parse_substitution(pair))),
+            Rule::char_seq => push_src!(pair.as_str()),
             // anything that isn't a substitution is a char_seq inside source
             _ => unreachable!(),
         }
@@ -76,6 +83,23 @@ fn parse_source(pairs: Pairs<Rule>) -> Vec<Source> {
     vec
 }
 
+fn parse_substitution(pair: Pair<Rule>) -> &'_ str {
+    match pair.as_rule() {
+        Rule::var_sub | Rule::arr_sub | Rule::pat_sub => {
+            let str = pair.as_str();
+            // return the value as the inner string for substitution
+            // all substitutions have the format of
+            //      *{ ... }
+            // we return everything except the first
+            // two characters: (sigil and preceding brace)
+            // and the trailing brace
+            &str[2..str.len() - 1]
+        }
+        // this function only gets called to parse substituiton patterns
+        _ => unreachable!(),
+    }
+}
+
 fn parse_assign(pair: Pair<Rule>) -> (&'_ str, &'_ str) {
     let mut key = "";
     let mut val = "";

diff --git a/src/tests/test_parser.rs b/src/tests/test_parser.rs
index c03cb3caa0486d97c8b1c8af18972089d0a79a21..c4774462aa7c660195517b6c1679f2cdf7636163 100644 (file)
--- a/src/tests/test_parser.rs
+++ b/src/tests/test_parser.rs
@@ -46,12 +46,12 @@ fn build_pattern_file() -> Result<()> {
     let mut pattern_src = parse_file(PATTERN)?.source.into_iter();
 
     pattern_src.next();
-    assert_eq!(pattern_src.next().unwrap(), source!(var("${var}")));
+    assert_eq!(pattern_src.next().unwrap(), source!(var("var")));
     pattern_src.next();
-    assert_eq!(pattern_src.next().unwrap(), source!(pat("&{pat}")));
-    assert_eq!(pattern_src.next().unwrap(), source!(arr("@{array}")));
+    assert_eq!(pattern_src.next().unwrap(), source!(pat("pat")));
+    assert_eq!(pattern_src.next().unwrap(), source!(arr("array")));
     pattern_src.next();
-    assert_eq!(pattern_src.next().unwrap(), source!(var("${blank}")));
+    assert_eq!(pattern_src.next().unwrap(), source!(var("blank")));
 
     Ok(())
 }