Started on a rust-cssparser frontend.

Also imported the test suite from less.js

Author: am0d

Cargo.toml

@@ -1,13 +1,15 @@
 [package]
-name = "rust"
+name = "cssparser"
 version = "0.0.0"
 
 authors = ["Your Name <your@email.com>"]
 tags = []
 
 [[lib]]
-name = "rust"
-path = "src/lib.rs"
+name = "cssparser"
+
+[[bin]]
+name = "rust-less"
 
 [dependencies.encoding]
 git = "https://github.com/lifthrasiir/rust-encoding.git"

src/ast.rs

@@ -2,9 +2,12 @@
  * 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)]
@@ -175,3 +178,201 @@ impl Iterator<ComponentValue> for MoveSkipWhitespaceIterator {
         None
     }
 }
+
+/* ToJson implementations for all the AST nodes
+ *
+ * These need to be implemented here because they can't be implemented in a
+ * crate that doesn't define these nodes
+ */
+
+macro_rules! JString {
+    ($e: expr) => { json::String($e.to_string()) }
+}
+
+macro_rules! JList {
+    ($($e: expr),*) => { json::List(vec!( $($e),* )) }
+}
+
+fn list_to_json(list: &Vec<(ComponentValue, SourceLocation)>) -> Vec<json::Json> {
+    list.iter().map(|tuple| {
+        match *tuple {
+            (ref c, _) => c.to_json()
+        }
+    }).collect()
+}
+
+impl ToJson for Result<Rule, SyntaxError> {
+    fn to_json(&self) -> json::Json {
+        match *self {
+            Ok(ref a) => a.to_json(),
+            Err(ref b) => b.to_json(),
+        }
+    }
+}
+
+
+impl ToJson for Result<DeclarationListItem, SyntaxError> {
+    fn to_json(&self) -> json::Json {
+        match *self {
+            Ok(ref a) => a.to_json(),
+            Err(ref b) => b.to_json(),
+        }
+    }
+}
+
+
+impl ToJson for Result<Declaration, SyntaxError> {
+    fn to_json(&self) -> json::Json {
+        match *self {
+            Ok(ref a) => a.to_json(),
+            Err(ref b) => b.to_json(),
+        }
+    }
+}
+
+
+impl ToJson for Result<ComponentValue, SyntaxError> {
+    fn to_json(&self) -> json::Json {
+        match *self {
+            Ok(ref a) => a.to_json(),
+            Err(ref b) => b.to_json(),
+        }
+    }
+}
+
+
+impl ToJson for SyntaxError {
+    fn to_json(&self) -> json::Json {
+        json::List(vec!(JString!("error"), JString!(match self.reason {
+            ErrEmptyInput => "empty",
+            ErrExtraInput => "extra-input",
+            _ => "invalid",
+        })))
+    }
+}
+
+
+impl ToJson for super::Color {
+    fn to_json(&self) -> json::Json {
+        use super::{RGBA, CurrentColor};
+
+        match *self {
+            RGBA(RGBA { red: r, green: g, blue: b, alpha: a }) => vec!(r, g, b, a).to_json(),
+            CurrentColor => JString!("currentColor"),
+        }
+    }
+}
+
+
+impl ToJson for Rule {
+    fn to_json(&self) -> json::Json {
+        match *self {
+            QualifiedRule(ref rule) => rule.to_json(),
+            AtRule(ref rule) => rule.to_json(),
+        }
+    }
+}
+
+
+impl ToJson for DeclarationListItem {
+    fn to_json(&self) -> json::Json {
+        match *self {
+            Declaration(ref declaration) => declaration.to_json(),
+            DeclAtRule(ref at_rule) => at_rule.to_json(),
+        }
+    }
+}
+
+impl ToJson for ComponentValue {
+    fn to_json(&self) -> json::Json {
+        fn numeric(value: &NumericValue) -> Vec<json::Json> {
+            match *value {
+                NumericValue{representation: ref r, value: ref v, int_value: ref i}
+                => vec!(r.to_json(), v.to_json(),
+                        JString!(match *i { Some(_) => "integer", _ => "number" }))
+            }
+        }
+
+        match *self {
+            Ident(ref value) => JList!(JString!("ident"), value.to_json()),
+            AtKeyword(ref value) => JList!(JString!("at-keyword"), value.to_json()),
+            Hash(ref value) => JList!(JString!("hash"), value.to_json(),
+                                      JString!("unrestricted")),
+            IDHash(ref value) => JList!(JString!("hash"), value.to_json(), JString!("id")),
+            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)),
+
+            Number(ref value) => json::List(vec!(JString!("number")) + numeric(value)),
+            Percentage(ref value) => json::List(vec!(JString!("percentage")) + numeric(value)),
+            Dimension(ref value, ref unit)
+            => json::List(vec!(JString!("dimension")) + numeric(value) + &[unit.to_json()]),
+
+            UnicodeRange(start, end)
+            => JList!(JString!("unicode-range"), start.to_json(), end.to_json()),
+
+            WhiteSpace => JString!(" "),
+            Colon => JString!(":"),
+            Semicolon => JString!(";"),
+            Comma => JString!(","),
+            IncludeMatch => JString!("~="),
+            DashMatch => JString!("|="),
+            PrefixMatch => JString!("^="),
+            SuffixMatch => JString!("$="),
+            SubstringMatch => JString!("*="),
+            Column => JString!("||"),
+            CDO => JString!("<!--"),
+            CDC => JString!("-->"),
+
+            Function(ref name, ref arguments)
+            => json::List(vec!(JString!("function"), name.to_json()) +
+                     arguments.iter().map(|a| a.to_json()).collect::<Vec<json::Json>>()),
+            ParenthesisBlock(ref content)
+            => json::List(vec!(JString!("()")) + content.iter().map(|c| c.to_json()).collect::<Vec<json::Json>>()),
+            SquareBracketBlock(ref content)
+            => json::List(vec!(JString!("[]")) + content.iter().map(|c| c.to_json()).collect::<Vec<json::Json>>()),
+            CurlyBracketBlock(ref content)
+            => json::List(vec!(JString!("{}")) + list_to_json(content)),
+
+            BadURL => JList!(JString!("error"), JString!("bad-url")),
+            BadString => JList!(JString!("error"), JString!("bad-string")),
+            CloseParenthesis => JList!(JString!("error"), JString!(")")),
+            CloseSquareBracket => JList!(JString!("error"), JString!("]")),
+            CloseCurlyBracket => JList!(JString!("error"), JString!("}")),
+        }
+    }
+}
+
+impl ToJson for AtRule {
+    fn to_json(&self) -> json::Json {
+        match *self {
+            AtRule{name: ref name, prelude: ref prelude, block: ref block, ..}
+            => json::List(vec!(JString!("at-rule"), name.to_json(),
+                               prelude.to_json(), block.as_ref().map(list_to_json).to_json()))
+        }
+    }
+}
+
+
+impl ToJson for QualifiedRule {
+    fn to_json(&self) -> json::Json {
+        match *self {
+            QualifiedRule{prelude: ref prelude, block: ref block, ..}
+            => json::List(vec!(JString!("qualified rule"),
+                               prelude.to_json(), json::List(list_to_json(block))))
+        }
+    }
+}
+
+
+impl ToJson for Declaration {
+    fn to_json(&self) -> json::Json {
+        match *self {
+            Declaration{name: ref name, value: ref value, important: ref important, ..}
+            =>  json::List(vec!(JString!("declaration"), name.to_json(),
+                                value.to_json(), important.to_json()))
+        }
+    }
+}
+