Small changes to ensure that we can output the original source.

This is almost complete now - only quotes appear to be incorrect.

Author: am0d

src/ast.rs

@@ -2,23 +2,22 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
-use std::str;
 use std::fmt;
 use std::slice;
 use std::vec;
 use serialize::{json};
 use serialize::json::ToJson;
 
 
-#[deriving(PartialEq)]
+#[deriving(PartialEq, Show)]
 pub struct NumericValue {
     pub representation: String,
     pub value: f64,
     pub int_value: Option<i64>,
 }
 
 
-#[deriving(PartialEq)]
+#[deriving(PartialEq, Show)]
 pub struct SourceLocation {
     pub line: uint,  // First line is 1
     pub column: uint,  // First character of a line is at column 1
@@ -28,7 +27,7 @@ pub struct SourceLocation {
 pub type Node = (ComponentValue, SourceLocation);  // TODO this is not a good name
 
 
-#[deriving(PartialEq)]
+#[deriving(PartialEq, Show)]
 pub enum ComponentValue {
     // Preserved tokens.
     Ident(String),
@@ -42,7 +41,7 @@ pub enum ComponentValue {
     Percentage(NumericValue),
     Dimension(NumericValue, String),
     UnicodeRange(u32, u32),  // (start, end) of range
-    WhiteSpace,
+    WhiteSpace(String),
     Colon,  // :
     Semicolon,  // ;
     Comma,  // ,
@@ -72,40 +71,41 @@ pub enum ComponentValue {
 }
 
 
-#[deriving(PartialEq)]
+#[deriving(PartialEq, Show)]
 pub struct Declaration {
     pub location: SourceLocation,
     pub name: String,
     pub value: Vec<ComponentValue>,
     pub important: bool,
 }
 
-#[deriving(PartialEq)]
+#[deriving(PartialEq, Show)]
 pub struct QualifiedRule {
     pub location: SourceLocation,
     pub prelude: Vec<ComponentValue>,
     pub block: Vec<Node>,
 }
 
-#[deriving(PartialEq)]
+#[deriving(PartialEq, Show)]
 pub struct AtRule {
     pub location: SourceLocation,
     pub name: String,
     pub prelude: Vec<ComponentValue>,
     pub block: Option<Vec<Node>>,
 }
 
-#[deriving(PartialEq)]
+#[deriving(PartialEq, Show)]
 pub enum DeclarationListItem {
     Declaration(Declaration),
     // A better idea for a name that means "at-rule" but is not "AtRule"?
     DeclAtRule(AtRule),
 }
 
-#[deriving(PartialEq)]
+#[deriving(PartialEq, Show)]
 pub enum Rule {
     QualifiedRule(QualifiedRule),
     AtRule(AtRule),
+    NonRule(ComponentValue)
 }
 
 #[deriving(PartialEq)]
@@ -114,7 +114,7 @@ pub struct SyntaxError {
     pub reason: ErrorReason,
 }
 
-#[deriving(PartialEq)]
+#[deriving(PartialEq, Show)]
 pub enum ErrorReason {
     ErrEmptyInput,  // Parsing a single "thing", found only whitespace.
     ErrExtraInput,  // Found more non-whitespace after parsing a single "thing".
@@ -149,7 +149,10 @@ pub struct SkipWhitespaceIterator<'a> {
 impl<'a> Iterator<&'a ComponentValue> for SkipWhitespaceIterator<'a> {
     fn next(&mut self) -> Option<&'a ComponentValue> {
         for component_value in self.iter_with_whitespace {
-            if component_value != &WhiteSpace { return Some(component_value) }
+            match component_value {
+                &WhiteSpace(_) => (),
+                _ => return Some(component_value)
+            }
         }
         None
     }
@@ -173,7 +176,10 @@ pub struct MoveSkipWhitespaceIterator {
 impl Iterator<ComponentValue> for MoveSkipWhitespaceIterator {
     fn next(&mut self) -> Option<ComponentValue> {
         for component_value in self.iter_with_whitespace {
-            if component_value != WhiteSpace { return Some(component_value) }
+            match component_value {
+                WhiteSpace(_) => (),
+                _ =>  return Some(component_value) 
+            }
         }
         None
     }
@@ -269,6 +275,7 @@ impl ToJson for Rule {
         match *self {
             QualifiedRule(ref rule) => rule.to_json(),
             AtRule(ref rule) => rule.to_json(),
+            NonRule(ref component_value) => component_value.to_json()
         }
     }
 }
@@ -302,7 +309,7 @@ impl ToJson for ComponentValue {
             String(ref value) => JList!(JString!("string"), value.to_json()),
             URL(ref value) => JList!(JString!("url"), value.to_json()),
             Delim('\\') => JString!("\\"),
-            Delim(value) => json::String(str::from_char(value)),
+            Delim(value) => json::String(String::from_char(1, value)),
 
             Number(ref value) => json::List(vec!(JString!("number")) + numeric(value)),
             Percentage(ref value) => json::List(vec!(JString!("percentage")) + numeric(value)),
@@ -312,7 +319,7 @@ impl ToJson for ComponentValue {
             UnicodeRange(start, end)
             => JList!(JString!("unicode-range"), start.to_json(), end.to_json()),
 
-            WhiteSpace => JString!(" "),
+            WhiteSpace(ref value) => JString!(value.to_json()),
             Colon => JString!(":"),
             Semicolon => JString!(";"),
             Comma => JString!(","),

src/bin/rust-less.rs

@@ -2,167 +2,101 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
-#![feature(macro_rules, globs)]
+#![feature(macro_rules, globs, phase)]
+
+#[phase(plugin, link)] extern crate log;
 
 extern crate serialize;
 extern crate encoding;
 extern crate cssparser;
 
-use std::{io, task};
-use std::io::{File, Command, Writer, TempDir};
-use serialize::{json};
-use serialize::json::ToJson;
-
-use encoding::label::encoding_from_whatwg_label;
+use std::io;
+use std::io::{File, Writer};
 
 use cssparser::*;
 use cssparser::ast::*;
 
-fn write_whole_file(path: &Path, data: &str) {
-    match File::open_mode(path, io::Open, io::Write) {
-        Ok(mut writer) => { writer.write(data.as_bytes()).unwrap(); },
-        _ => fail!("could not open file"),
-    }
-}
+macro_rules! try_write(
+    ($buf:expr, $($args:tt)*) => (match write!($buf, $($args)*) { Ok(e) => e, Err(_e) => return Err(()) })
+)
 
+fn print_css(mut rules: Vec<Result<Rule, SyntaxError>>) -> Result<String, ()> {
+    let mut buffer = io::MemWriter::new();
 
-fn almost_equals(a: &json::Json, b: &json::Json) -> bool {
-    match (a, b) {
-        (&json::Number(a), &json::Number(b)) => (a - b).abs() < 1e-6,
-        (&json::String(ref a), &json::String(ref b)) => a == b,
-        (&json::Boolean(a), &json::Boolean(b)) => a == b,
-        (&json::List(ref a), &json::List(ref b))
-            => a.iter().zip(b.iter()).all(|(ref a, ref b)| almost_equals(*a, *b)),
-        (&json::Object(_), &json::Object(_)) => fail!("Not implemented"),
-        (&json::Null, &json::Null) => true,
-        _ => false,
+    fn print_prelude(buffer: &mut io::MemWriter, 
+                     prelude: &mut Vec<ComponentValue>) -> Result<(), ()> {
+        for p in prelude.mut_iter() {
+            try_write!(buffer, "{}", p.to_css());
+        }
+        Ok(())
     }
-}
 
+    fn print_block(buffer: &mut io::MemWriter, 
+                   block: &mut Vec<Node>) -> Result<(), ()> {
+        try_write!(buffer, "{{");
+        for &(ref mut b, _) in block.mut_iter() {
+            try_write!(buffer, "{}", b.to_css());
+        }
+        try_write!(buffer, "}}");
 
-fn assert_json_eq(results: json::Json, expected: json::Json, message: String) {
-    if !almost_equals(&results, &expected) {
-        let temp = TempDir::new("rust-cssparser-tests").unwrap();
-        let results = results.to_pretty_str().append("\n");
-        let expected = expected.to_pretty_str().append("\n");
-        task::try(proc() {
-            let mut result_path = temp.path().clone();
-            result_path.push("results.json");
-            let mut expected_path = temp.path().clone();
-            expected_path.push("expected.json");
-            write_whole_file(&result_path, results.as_slice());
-            write_whole_file(&expected_path, expected.as_slice());
-            Command::new("colordiff")
-                .arg("-u1000")
-                .arg(result_path)
-                .arg(expected_path)
-                .status().unwrap_or_else(|e| fail!("Failed to get status of colordiff: {}", e));
-        }).unwrap_or_else(|_e| fail!("Failed to execute task"));
-
-        fail!(message)
+        Ok(())
     }
-}
 
-
-fn run_raw_json_tests(json_data: &str, run: |json::Json, json::Json|) {
-    let items = match json::from_str(json_data) {
-        Ok(json::List(items)) => items,
-        _ => fail!("Invalid JSON")
-    };
-    assert!(items.len() % 2 == 0);
-    let mut input = None;
-    for item in items.move_iter() {
-        match (&input, item) {
-            (&None, json_obj) => input = Some(json_obj),
-            (&Some(_), expected) => {
-                let input = input.take_unwrap();
-                run(input, expected)
+    for r in rules.mut_iter() {
+        match *r {
+            Ok(ref mut rule) => {
+                match *rule {
+                    QualifiedRule(ref mut q) => {
+                        try!(print_prelude(&mut buffer, &mut q.prelude));
+                        try!(print_block(&mut buffer, &mut q.block));
+                    },
+                    AtRule(ref mut a) => {
+                        //try_write!(buffer, "{}\n", a);
+                        try_write!(buffer, "@{}", a.name);
+                        try!(print_prelude(&mut buffer, &mut a.prelude));
+                        match a.block {
+                            None => (),
+                            Some(ref mut b) => try!(print_block(&mut buffer, b))
+                        }
+                    },
+                    NonRule(ref mut component_value) => {
+                        try_write!(buffer, "{}", component_value.to_css());
+                    }
+                }
             },
+            Err(e) => {
+                try_write!(buffer, "Err: {}", e);
+            }
         };
     }
-}
-
-
-fn run_json_tests<T: ToJson>(json_data: &str, parse: |input: &str| -> T) {
-    run_raw_json_tests(json_data, |input, expected| {
-        match input {
-            json::String(input) => {
-                let result = parse(input.as_slice()).to_json();
-                assert_json_eq(result, expected, input);
-            },
-            _ => fail!("Unexpected JSON")
-        }
-    });
-}
-
 
-
-#[test]
-fn stylesheet() {
-    /*run_json_tests(include_str!("../css-parsing-tests/stylesheet.json"), |input| {
-        parse_stylesheet_rules(tokenize(input)).collect::<Vec<Result<Rule, SyntaxError>>>()
-    });*/
+    String::from_utf8(buffer.unwrap())
+        .map_err(|_| ())
 }
 
-#[test]
-fn stylesheet_from_bytes() {
-    /*run_raw_json_tests(include_str!("../css-parsing-tests/stylesheet_bytes.json"),
-    |input, expected| {
-        let map = match input {
-            json::Object(map) => map,
-            _ => fail!("Unexpected JSON")
-        };
-
-        let result = {
-            let css = get_string(&map, &"css_bytes".to_string()).unwrap().chars().map(|c| {
-                assert!(c as u32 <= 0xFF);
-                c as u8
-            }).collect::<Vec<u8>>();
-            let protocol_encoding_label = get_string(&map, &"protocol_encoding".to_string());
-            let environment_encoding = get_string(&map, &"environment_encoding".to_string())
-                .and_then(encoding_from_whatwg_label);
-
-            let (mut rules, used_encoding) = parse_stylesheet_rules_from_bytes(
-                css.as_slice(), protocol_encoding_label, environment_encoding);
-
-            (rules.collect::<Vec<Result<Rule, SyntaxError>>>(), used_encoding.name().to_string()).to_json()
-        };
-        assert_json_eq(result, expected, json::Object(map).to_pretty_str());
-    });
-
-    fn get_string<'a>(map: &'a json::Object, key: &String) -> Option<&'a str> {
-        match map.find(key) {
-            Some(&json::String(ref s)) => Some(s.as_slice()),
-            Some(&json::Null) => None,
-            None => None,
-            _ => fail!("Unexpected JSON"),
-        }
-    }*/
+fn print_json(rules: &Vec<Result<Rule, SyntaxError>>) {
+    use serialize::json::ToJson;
+    debug!("{}", rules.to_json());
 }
 
-
-fn run_color_tests(json_data: &str, to_json: |result: Option<Color>| -> json::Json) {
-    run_json_tests(json_data, |input| {
-        match parse_one_component_value(tokenize(input)) {
-            Ok(component_value) => to_json(Color::parse(&component_value)),
-            Err(_reason) => json::Null,
-        }
-    });
-}
-
-
 fn main() {
-    let contents = File::open(&Path::new("test/less/css.less")).read_to_end();
+    let contents = File::open(&Path::new("test/less/variables.less")).read_to_end();
 
     let contents = match contents {
         Err(e) => fail!(e),
         Ok(c) => c
     };
 
-    println!("{}", contents);
+    let (css_unicode, _encoding) = decode_stylesheet_bytes(contents.as_slice(), None, None);
+    
+    let tokens = tokenize(css_unicode.as_slice());
+    let mut rules = parse_stylesheet_rules(tokens);
 
-    let (mut rules, used_encoding) = cssparser::parse_stylesheet_rules_from_bytes(
-        contents.as_slice(), None, None);
+    let rules = rules.collect::<Vec<Result<Rule, SyntaxError>>>();
+    print_json(&rules);
 
-    println!("{}", rules.collect::<Vec<Result<Rule, SyntaxError>>>().to_json());
+    match print_css(rules) {
+        Ok(res) => println!("{}", res),
+        Err(e) => println!("Err: {}", e)
+    }
 }

src/from_bytes.rs

@@ -3,7 +3,6 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use std::cmp;
-use std::str;
 
 use encoding::label::encoding_from_whatwg_label;
 use encoding::all::UTF_8;
@@ -50,7 +49,7 @@ pub fn decode_stylesheet_bytes(css: &[u8], protocol_encoding_label: Option<&str>
             Some(label_length)
             => if css.slice_from(10 + label_length).starts_with("\";".as_bytes()) {
                 let label = css.slice(10, 10 + label_length);
-                let label = str::from_chars(label.iter().map(|&b| b as char).collect::<Vec<char>>().as_slice());
+                let label = String::from_chars(label.iter().map(|&b| b as char).collect::<Vec<char>>().as_slice());
                 match encoding_from_whatwg_label(label.as_slice()) {
                     None => (),
                     Some(fallback) => match fallback.name() {