try_read_pattern refactor to use new escaped strings

Author: Tko1

src/reader.rs

@@ -401,57 +401,24 @@ pub fn try_read_string(input: &str) -> IResult<&str, Value> {
     to_value_parser(string_parser)(rest_input)
 }
 
-/// Tries to parse &str into Value::Pattern
-/// Reader Macro for Regex
-/// Example Successes:
-///    #"this is pretty straightforward" => Value::Pattern("this is pretty straightforward")
 pub fn try_read_pattern(input: &str) -> IResult<&str, Value> {
-    named!(hash_quotation<&str, &str>, preceded!(consume_clojure_whitespaces_parser, tag!("#\"")));
-
-    let (rest_input, _) = hash_quotation(input)?;
-
-    // println!("regexquoted: {:#?}", regex::Regex::quote(rest_input));
-    let mut iterator = rest_input.escape_default();
-    let mut prev: char = iterator.next().unwrap();
-    let mut prev_prev_was_escape = false;
-    let mut is_escaping = false;
-    let mut till_quote: String = String::from(prev.to_string());
-    println!("first char: {:#?}", till_quote);
-    while let ch = iterator.next().unwrap() {
-        if ch == '\\' && prev == '\\' {
-            is_escaping = true;
-        }
-        println!(
-            "LOOP: next char to handle: {:#?} prev: {:#?} is escaping {} and prev prev was escaping {}",
-            ch, prev, is_escaping, prev_prev_was_escape
-        );
-        if ch == '\"' && prev == '\\' && !prev_prev_was_escape {
-            println!(
-                "GONNA END: next char to handle: {:#?} prev: {:#?} is escaping {}",
-                ch, prev, is_escaping
-            );
-            till_quote = till_quote.trim_end_matches("\"").to_string();
-            break;
-        };
-        if ch == '\"' && is_escaping {
-            till_quote = String::from(till_quote + ch.to_string().as_str());
-        } else if ch != '\\' {
-            till_quote = String::from(till_quote + ch.to_string().as_str());
-            //is_escaping = false;
-            prev_prev_was_escape = false;
-        }
-        prev_prev_was_escape = is_escaping;
-        prev = ch;
+    named!(hash_parser<&str, &str>, preceded!(consume_clojure_whitespaces_parser, tag!("#")));
+
+    let (rest_input, _) = hash_parser(input)?; 
+    let (rest_input,regex_string_val) = try_read_string(rest_input)?;
+
+    let mut regex_string = String::from("");
+
+    // @TODO separate try_read_string into a parser, so we don't have to read a Value
+    // and then unwrap it 
+    match regex_string_val {
+        Value::String(reg_str) => { regex_string = reg_str; },
+        _ => { panic!("try_read_string returned something that wasn't string"); }
     }
-    println!("till quote: {} {:#?}", till_quote, till_quote);
-    let to_trim = till_quote.to_owned() + "\"";
-    println!(
-        "rest input trimmed: {}",
-        rest_input.trim_start_matches(&to_trim)
-    );
-    let regex = regex::Regex::new(till_quote.as_str()).unwrap();
+
+    let regex = regex::Regex::new(regex_string.as_str()).unwrap();
     Ok((
-        rest_input.trim_start_matches(&to_trim),
+        rest_input,
         Value::Pattern(regex),
     ))
 }