clean up

scorpdx · Aug 31, 2019 · ee5c9aa · ee5c9aa
1 parent 21166f1
commit ee5c9aa
Showing 1 changed file with 10 additions and 66 deletions.
diff --git a/src/main.rs b/src/main.rs
@@ -21,8 +21,7 @@ enum JSONValue<'a> {
     Array(Vec<JSONValue<'a>>),
     String(&'a str),
     Number(f64),
-    Boolean(bool),
-    Null,
+    Boolean(bool)
 }
 
 fn serialize_jsonvalue(val: &JSONValue) -> String {
@@ -43,8 +42,7 @@ fn serialize_jsonvalue(val: &JSONValue) -> String {
         }
         String(s) => format!("\"{}\"", s),
         Number(n) => format!("{}", n),
-        Boolean(b) => format!("{}", b),
-        Null => format!("null"),
+        Boolean(b) => format!("{}", b)
     }
 }
 
@@ -55,7 +53,6 @@ fn parse_json_file(file: &str) -> Result<JSONValue, Error<Rule>> {
 
     fn parse_value(pair: Pair<Rule>) -> JSONValue {
         match pair.as_rule() {
-            //Rule::header => JSONValue::Object(vec![(pair.as_str(), parse_value(pair.into_inner().next().unwrap()))]),
             Rule::object
             | Rule::body => JSONValue::Object(
                 pair.into_inner()
@@ -64,46 +61,19 @@ fn parse_json_file(file: &str) -> Result<JSONValue, Error<Rule>> {
                         let inner_pair = inner_rules
                             .next()
                             .expect("inner_pair was None");
-                        let inner_pair_identifier = inner_pair;
-                            // .into_inner()
-                            // .next();
-                            //.expect("inner_pair_identifier was None");
-                        let name = inner_pair_identifier.as_str();/* match inner_pair_identifier {
-                            Some(ipi) => ipi.as_str(),
-                            None => ""
-                        }; */
-                        let value = parse_value(inner_rules.next().expect("@3 inner_rules.next() was None"));
-                        // println!("JSONValue::Object {0}:{1}", name, serialize_jsonvalue(&value));
+                        let name = inner_pair.as_str();
+                        let value = parse_value(inner_rules.next().expect("inner_rules.next() was None"));
                         (name, value)
                     })
                     .collect(),
             ),
-            Rule::array => {
-                // println!("JSONValue::Array");
-                JSONValue::Array(pair.into_inner().map(parse_value).collect())
-            },
+            Rule::array => JSONValue::Array(pair.into_inner().map(parse_value).collect()),
             Rule::string
-            | Rule::date => {
-                let instr = pair.into_inner().next().unwrap().as_str();
-                // println!("JSONValue::String {0}", instr);
-                JSONValue::String(instr)
-            },
-            Rule::tag => {
-                 let instr = pair.as_str();
-            //    println!("JSONValue::String {0}", instr);
-               JSONValue::String(instr)
-            },
-            Rule::number => {
-                let innum = pair.as_str().parse().unwrap();
-                // println!("JSONValue::Number {0}", innum);
-                JSONValue::Number(innum)
-            },
-            Rule::boolean => {
-                let inbool = pair.as_str() == "yes";
-                // println!("JSONValue::Boolean {0}", inbool);
-                JSONValue::Boolean(inbool)
-            },
-            //Rule::null => JSONValue::Null,
+            | Rule::date => 
+                JSONValue::String(pair.into_inner().next().unwrap().as_str()),
+            Rule::tag => JSONValue::String(pair.as_str()),
+            Rule::number => JSONValue::Number(pair.as_str().parse().unwrap()),
+            Rule::boolean => JSONValue::Boolean(pair.as_str() == "yes"),
             Rule::file
             | Rule::EOI
             | Rule::header
@@ -141,7 +111,6 @@ fn main() {
         .get_matches();
 
     let filename = matches.value_of("file").unwrap();
-    println!("{}", filename);
     let file = File::open(filename).expect("cannot open file");
 
     let mut transcoded = DecodeReaderBytesBuilder::new().encoding(Some(WINDOWS_1252)).build(file);
@@ -152,29 +121,4 @@ fn main() {
     let json: JSONValue = parse_json_file(&file_text).expect("unsuccessful parse");
 
     println!("{}", serialize_jsonvalue(&json));
-    return;
-
-    let pairs = CK2Parser::parse(Rule::file, &file_text).unwrap_or_else(|e| panic!("{}", e));
-
-    // Because ident_list is silent, the iterator will contain idents
-    for pair in pairs {
-        // A pair is a combination of the rule which matched and a span of input
-        println!("Rule:    {:?}", pair.as_rule());
-        println!("Span:    {:?}", pair.as_span());
-        println!("Text:    {}", pair.as_str());
-
-        // A pair can be converted to an iterator of the tokens which make it up:
-        for inner_pair in pair.into_inner() {
-            println!("InnerRule:    {:?}", inner_pair.as_rule());
-            println!("InnerSpan:    {:?}", inner_pair.as_span());
-            println!("InnerText:    {}", inner_pair.as_str());
-
-            /* match inner_pair.as_rule() {
-                Rule::identifier => println!("ok"),
-                // Rule::alpha => println!("Letter:  {}", inner_pair.as_str()),
-                // Rule::digit => println!("Digit:   {}", inner_pair.as_str()),
-                _ => unreachable!()
-            }; */
-        }
-    }
 }