Update to build again and build with cargo

Author: am0d

.gitignore

@@ -8,3 +8,6 @@
 *.dummy
 *-test
 Makefile
+target/
+doc/
+.*.swp

Cargo.toml

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

ast.rs renamed to src/ast.rs

@@ -205,10 +205,10 @@ fn parse_color_hash(value: &str) -> Option<Color> {
     macro_rules! from_hex(
         ($c: expr) => {{
             let c = $c;
-            match c as char {
-                '0' .. '9' => c - ('0' as u8),
-                'a' .. 'f' => c - ('a' as u8) + 10,
-                'A' .. 'F' => c - ('A' as u8) + 10,
+            match c {
+                '0' .. '9' => (c as u8) - ('0' as u8),
+                'a' .. 'f' => (c as u8) - ('a' as u8) + 10,
+                'A' .. 'F' => (c as u8) - ('A' as u8) + 10,
                 _ => return None  // Not a valid color
             }
         }};
@@ -224,14 +224,14 @@ fn parse_color_hash(value: &str) -> Option<Color> {
 
     match value.len() {
         6 => to_rgba!(
-            from_hex!(value[0]) * 16 + from_hex!(value[1]),
-            from_hex!(value[2]) * 16 + from_hex!(value[3]),
-            from_hex!(value[4]) * 16 + from_hex!(value[5]),
+            from_hex!(value.char_at(0)) * 16 + from_hex!(value.char_at(1)),
+            from_hex!(value.char_at(2)) * 16 + from_hex!(value.char_at(3)),
+            from_hex!(value.char_at(4)) * 16 + from_hex!(value.char_at(5)),
         ),
         3 => to_rgba!(
-            from_hex!(value[0]) * 17,
-            from_hex!(value[1]) * 17,
-            from_hex!(value[2]) * 17,
+            from_hex!(value.char_at(0)) * 17,
+            from_hex!(value.char_at(1)) * 17,
+            from_hex!(value.char_at(2)) * 17,
         ),
         _ => None
     }

color.rs renamed to src/color.rs

@@ -2,7 +2,7 @@
  * 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/. */
 
-#![crate_id = "github.com/mozilla-servo/rust-cssparser#cssparser:0.1"]
+#![crate_name = "rust-cssparser"]
 #![crate_type = "lib"]
 #![crate_type = "dylib"]
 #![crate_type = "rlib"]

from_bytes.rs renamed to src/from_bytes.rs

@@ -58,10 +58,10 @@ fn assert_json_eq(results: json::Json, expected: json::Json, message: String) {
             write_whole_file(&expected_path, expected.as_slice());
             Command::new("colordiff")
                 .arg("-u1000")
-                .arg(result_path.display().to_str())
-                .arg(expected_path.display().to_str())
-                .status().unwrap();
-        }).unwrap();
+                .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)
     }
@@ -102,84 +102,84 @@ fn run_json_tests<T: ToJson>(json_data: &str, parse: |input: &str| -> T) {
 
 #[test]
 fn component_value_list() {
-    run_json_tests(include_str!("css-parsing-tests/component_value_list.json"), |input| {
+    run_json_tests(include_str!("../css-parsing-tests/component_value_list.json"), |input| {
         tokenize(input).map(|(c, _)| c).collect::<Vec<ComponentValue>>()
     });
 }
 
 
 #[test]
 fn one_component_value() {
-    run_json_tests(include_str!("css-parsing-tests/one_component_value.json"), |input| {
+    run_json_tests(include_str!("../css-parsing-tests/one_component_value.json"), |input| {
         parse_one_component_value(tokenize(input))
     });
 }
 
 
 #[test]
 fn declaration_list() {
-    run_json_tests(include_str!("css-parsing-tests/declaration_list.json"), |input| {
+    run_json_tests(include_str!("../css-parsing-tests/declaration_list.json"), |input| {
         parse_declaration_list(tokenize(input)).collect::<Vec<Result<DeclarationListItem, SyntaxError>>>()
     });
 }
 
 
 #[test]
 fn one_declaration() {
-    run_json_tests(include_str!("css-parsing-tests/one_declaration.json"), |input| {
+    run_json_tests(include_str!("../css-parsing-tests/one_declaration.json"), |input| {
         parse_one_declaration(tokenize(input))
     });
 }
 
 
 #[test]
 fn rule_list() {
-    run_json_tests(include_str!("css-parsing-tests/rule_list.json"), |input| {
+    run_json_tests(include_str!("../css-parsing-tests/rule_list.json"), |input| {
         parse_rule_list(tokenize(input)).collect::<Vec<Result<Rule, SyntaxError>>>()
     });
 }
 
 
 #[test]
 fn stylesheet() {
-    run_json_tests(include_str!("css-parsing-tests/stylesheet.json"), |input| {
+    run_json_tests(include_str!("../css-parsing-tests/stylesheet.json"), |input| {
         parse_stylesheet_rules(tokenize(input)).collect::<Vec<Result<Rule, SyntaxError>>>()
     });
 }
 
 
 #[test]
 fn one_rule() {
-    run_json_tests(include_str!("css-parsing-tests/one_rule.json"), |input| {
+    run_json_tests(include_str!("../css-parsing-tests/one_rule.json"), |input| {
         parse_one_rule(tokenize(input))
     });
 }
 
 
 #[test]
 fn stylesheet_from_bytes() {
-    run_raw_json_tests(include_str!("css-parsing-tests/stylesheet_bytes.json"),
+    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| {
+            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())
+            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_str());
+        assert_json_eq(result, expected, json::Object(map).to_pretty_str());
     });
 
     fn get_string<'a>(map: &'a json::Object, key: &String) -> Option<&'a str> {
@@ -205,20 +205,20 @@ fn run_color_tests(json_data: &str, to_json: |result: Option<Color>| -> json::Js
 
 #[test]
 fn color3() {
-    run_color_tests(include_str!("css-parsing-tests/color3.json"), |c| c.to_json())
+    run_color_tests(include_str!("../css-parsing-tests/color3.json"), |c| c.to_json())
 }
 
 
 #[test]
 fn color3_hsl() {
-    run_color_tests(include_str!("css-parsing-tests/color3_hsl.json"), |c| c.to_json())
+    run_color_tests(include_str!("../css-parsing-tests/color3_hsl.json"), |c| c.to_json())
 }
 
 
 /// color3_keywords.json is different: R, G and B are in 0..255 rather than 0..1
 #[test]
 fn color3_keywords() {
-    run_color_tests(include_str!("css-parsing-tests/color3_keywords.json"), |c| {
+    run_color_tests(include_str!("../css-parsing-tests/color3_keywords.json"), |c| {
         match c {
             Some(RGBA(RGBA { red: r, green: g, blue: b, alpha: a }))
             => vec!(r * 255., g * 255., b * 255., a).to_json(),
@@ -252,15 +252,15 @@ fn bench_color_lookup_fail(b: &mut test::Bencher) {
 
 #[test]
 fn nth() {
-    run_json_tests(include_str!("css-parsing-tests/An+B.json"), |input| {
+    run_json_tests(include_str!("../css-parsing-tests/An+B.json"), |input| {
         parse_nth(tokenize(input).map(|(c, _)| c).collect::<Vec<ComponentValue>>().as_slice())
     });
 }
 
 
 #[test]
 fn serializer() {
-    run_json_tests(include_str!("css-parsing-tests/component_value_list.json"), |input| {
+    run_json_tests(include_str!("../css-parsing-tests/component_value_list.json"), |input| {
         let component_values = tokenize(input).map(|(c, _)| c).collect::<Vec<ComponentValue>>();
         let serialized = component_values.iter().to_css();
         tokenize(serialized.as_slice()).map(|(c, _)| c).collect::<Vec<ComponentValue>>()