Merge pull request #37 from larsbergstrom/rust_20140224

metajack · metajack · commit e5aee9b18293 · 2014-03-18T11:32:35.000-06:00
Rust 20140224
diff --git a/Makefile.in b/Makefile.in
@@ -13,7 +13,7 @@ RUST_SRC=$(shell find $(VPATH)/. -type f -name '*.rs')
 all:    libcssparser.dummy
 
 libcssparser.dummy: lib.rs $(RUST_SRC)
-	$(RUSTC) $(RUSTFLAGS) $< --lib --out-dir .
+	$(RUSTC) $(RUSTFLAGS) $< --crate-type=lib --out-dir .
 	touch $@
 
 cssparser-test: lib.rs $(RUST_SRC)
diff --git a/ast.rs b/ast.rs
@@ -2,6 +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/. */
 
+use std::fmt;
 use std::vec;
 
 
@@ -94,7 +95,7 @@ pub struct AtRule {
 pub enum DeclarationListItem {
     Declaration(Declaration),
     // A better idea for a name that means "at-rule" but is not "AtRule"?
-    Decl_AtRule(AtRule),
+    DeclAtRule(AtRule),
 }
 
 #[deriving(Eq)]
@@ -119,9 +120,9 @@ pub enum ErrorReason {
     // This is meant to be extended
 }
 
-impl ToStr for SyntaxError {
-    fn to_str(&self) -> ~str {
-        format!("{:u}:{:u} {:?}", self.location.line, self.location.column, self.reason)
+impl fmt::Show for SyntaxError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f.buf, "{:u}:{:u} {:?}", self.location.line, self.location.column, self.reason)
     }
 }
 
@@ -138,7 +139,7 @@ impl<'a> SkipWhitespaceIterable<'a> for &'a [ComponentValue] {
 
 #[deriving(Clone)]
 pub struct SkipWhitespaceIterator<'a> {
-    iter_with_whitespace: vec::VecIterator<'a, ComponentValue>,
+    iter_with_whitespace: vec::Items<'a, ComponentValue>,
 }
 
 impl<'a> Iterator<&'a ComponentValue> for SkipWhitespaceIterator<'a> {
@@ -162,7 +163,7 @@ impl MoveSkipWhitespaceIterable for ~[ComponentValue] {
 }
 
 pub struct MoveSkipWhitespaceIterator {
-    iter_with_whitespace: vec::MoveIterator<ComponentValue>,
+    iter_with_whitespace: vec::MoveItems<ComponentValue>,
 }
 
 impl Iterator<ComponentValue> for MoveSkipWhitespaceIterator {
diff --git a/color.rs b/color.rs
@@ -3,6 +3,7 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use std::ascii::StrAsciiExt;
+use std::cmp;
 
 use ast::*;
 
@@ -250,7 +251,7 @@ fn parse_color_function(name: &str, arguments: &[ComponentValue])
 
     let mut iter = arguments.skip_whitespace();
     macro_rules! expect_comma(
-        () => ( if iter.next() != Some(&Comma) { return None } );
+        () => ( match iter.next() { Some(&Comma) => {}, _ => { return None } } );
     )
     macro_rules! expect_percentage(
         () => ( match iter.next() {
@@ -297,9 +298,9 @@ fn parse_color_function(name: &str, arguments: &[ComponentValue])
         let hue = expect_number!() / 360.;
         let hue = hue - hue.floor();
         expect_comma!();
-        let saturation = (expect_percentage!() / 100.).max(&0.).min(&1.);
+        let saturation = cmp::min(cmp::max((expect_percentage!() / 100.), 0.), 1.);
         expect_comma!();
-        let lightness = (expect_percentage!() / 100.).max(&0.).min(&1.);
+        let lightness = cmp::min(cmp::max((expect_percentage!() / 100.), 0.), 1.);
 
         // http://www.w3.org/TR/css3-color/#hsl-color
         fn hue_to_rgb(m1: f64, m2: f64, mut h: f64) -> f64 {
@@ -321,7 +322,7 @@ fn parse_color_function(name: &str, arguments: &[ComponentValue])
 
     let alpha = if has_alpha {
         expect_comma!();
-        (expect_number!()).max(&0.).min(&1.) as f32
+        cmp::min(cmp::max((expect_number!()), 0.), 1.) as f32
     } else {
         1.
     };
diff --git a/from_bytes.rs b/from_bytes.rs
@@ -2,6 +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/. */
 
+use std::cmp;
 use std::str;
 
 use encoding::label::encoding_from_whatwg_label;
@@ -44,7 +45,7 @@ pub fn decode_stylesheet_bytes(css: &[u8], protocol_encoding_label: Option<&str>
     if css.starts_with("@charset \"".as_bytes()) {
         // 10 is "@charset \"".len()
         // 100 is arbitrary so that no encoding label is more than 100-10 bytes.
-        match css.slice(10, css.len().min(&100)).position_elem(&('"' as u8)) {
+        match css.slice(10, cmp::min(css.len(), 100)).position_elem(&('"' as u8)) {
             None => (),
             Some(label_length)
             => if css.slice_from(10 + label_length).starts_with("\";".as_bytes()) {
diff --git a/lib.rs b/lib.rs
@@ -5,8 +5,11 @@
 #[crate_id = "github.com/mozilla-servo/rust-cssparser#cssparser:0.1"];
 #[feature(globs, macro_rules)];
 
-extern mod extra;
-extern mod encoding;  // https://github.com/lifthrasiir/rust-encoding
+extern crate extra;
+extern crate encoding;  // https://github.com/lifthrasiir/rust-encoding
+
+#[cfg(test)]
+extern crate test;
 
 pub use tokenizer::tokenize;
 pub use parser::{parse_stylesheet_rules, parse_rule_list, parse_declaration_list,
diff --git a/nth.rs b/nth.rs
@@ -23,7 +23,7 @@ pub fn parse_nth(input: &[ComponentValue]) -> Option<(i32, i32)> {
                 match unit {
                     "n" => parse_b(iter, a as i32),
                     "n-" => parse_signless_b(iter, a as i32, -1),
-                    _ => match(parse_n_dash_digits(unit)) {
+                    _ => match parse_n_dash_digits(unit) {
                         Some(b) => parse_end(iter, a as i32, b),
                         _ => None
                     },
@@ -40,11 +40,11 @@ pub fn parse_nth(input: &[ComponentValue]) -> Option<(i32, i32)> {
                 "-n" => parse_b(iter, -1),
                 "n-" => parse_signless_b(iter, 1, -1),
                 "-n-" => parse_signless_b(iter, -1, -1),
-                _ if ident.starts_with("-") => match(parse_n_dash_digits(ident.slice_from(1))) {
+                _ if ident.starts_with("-") => match parse_n_dash_digits(ident.slice_from(1)) {
                     Some(b) => parse_end(iter, -1, b),
                     _ => None
                 },
-                _ =>  match(parse_n_dash_digits(ident)) {
+                _ =>  match parse_n_dash_digits(ident) {
                     Some(b) => parse_end(iter, 1, b),
                     _ => None
                 },
@@ -56,7 +56,7 @@ pub fn parse_nth(input: &[ComponentValue]) -> Option<(i32, i32)> {
                 match ident {
                     "n" => parse_b(iter, 1),
                     "n-" => parse_signless_b(iter, 1, -1),
-                    _ => match(parse_n_dash_digits(ident)) {
+                    _ => match parse_n_dash_digits(ident) {
                         Some(b) => parse_end(iter, 1, b),
                         _ => None
                     },
diff --git a/parser.rs b/parser.rs
@@ -160,7 +160,7 @@ for DeclarationListParser<T> {
             match component_value {
                 WhiteSpace | Semicolon => (),
                 AtKeyword(name)
-                => return Some(Ok(Decl_AtRule(parse_at_rule(iter, name, location)))),
+                => return Some(Ok(DeclAtRule(parse_at_rule(iter, name, location)))),
                 _ => return Some(match parse_declaration(iter, component_value, location) {
                     Ok(declaration) => Ok(Declaration(declaration)),
                     Err(e) => {
diff --git a/tests.rs b/tests.rs
@@ -2,12 +2,11 @@
  * 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, run, task};
-use std::io;
-use std::io::{File, Writer};
+use std::{io, str, task};
+use std::io::{File, Process, Writer};
 use extra::{tempfile, json};
 use extra::json::ToJson;
-use extra::test;
+use test;
 
 use encoding::label::encoding_from_whatwg_label;
 
@@ -17,8 +16,8 @@ use ast::*;
 
 fn write_whole_file(path: &Path, data: &str) {
     match File::open_mode(path, io::Open, io::Write) {
-        Some(mut writer) => writer.write(data.as_bytes()),
-        None => fail!("could not open file"),
+        Ok(mut writer) => { writer.write(data.as_bytes()); },
+        _ => fail!("could not open file"),
     }
 }
 
@@ -49,8 +48,8 @@ fn assert_json_eq(results: json::Json, expected: json::Json, message: ~str) {
             expected_path.push("expected.json");
             write_whole_file(&result_path, results);
             write_whole_file(&expected_path, expected);
-            run::process_status("colordiff", [~"-u1000", result_path.display().to_str(),
-                                              expected_path.display().to_str()]);
+            Process::status("colordiff", [~"-u1000", result_path.display().to_str(),
+                                          expected_path.display().to_str()]);
         });
 
         fail!(message)
@@ -333,7 +332,7 @@ impl ToJson for DeclarationListItem {
     fn to_json(&self) -> json::Json {
         match *self {
             Declaration(ref declaration) => declaration.to_json(),
-            Decl_AtRule(ref at_rule) => at_rule.to_json(),
+            DeclAtRule(ref at_rule) => at_rule.to_json(),
         }
     }
 }
diff --git a/tokenizer.rs b/tokenizer.rs
@@ -185,9 +185,8 @@ fn next_component_value(tokenizer: &mut Tokenizer) -> Option<Node> {
             }
         },
         '.' => {
-            if (
-                tokenizer.position + 1 < tokenizer.length
-                && is_match!(tokenizer.char_at(1), '0'..'9')
+            if tokenizer.position + 1 < tokenizer.length
+                && is_match!(tokenizer.char_at(1), '0'..'9'
             ) {
                 consume_numeric(tokenizer)
             } else {

Original file line number	Diff line number	Diff line change
`@@ -2,6 +2,7 @@`
`2`	`2`	`* License, v. 2.0. If a copy of the MPL was not distributed with this`
`3`	`3`	`* file, You can obtain one at http://mozilla.org/MPL/2.0/. */`
`4`	`4`
	`5`	`+use std::fmt;`
`5`	`6`	`use std::vec;`
`6`	`7`
`7`	`8`
`@@ -94,7 +95,7 @@ pub struct AtRule {`
`94`	`95`	`pub enum DeclarationListItem {`
`95`	`96`	`Declaration(Declaration),`
`96`	`97`	`// A better idea for a name that means "at-rule" but is not "AtRule"?`
`97`		`- Decl_AtRule(AtRule),`
	`98`	`+ DeclAtRule(AtRule),`
`98`	`99`	`}`
`99`	`100`
`100`	`101`	`#[deriving(Eq)]`
`@@ -119,9 +120,9 @@ pub enum ErrorReason {`
`119`	`120`	`// This is meant to be extended`
`120`	`121`	`}`
`121`	`122`
`122`		`-impl ToStr for SyntaxError {`
`123`		`- fn to_str(&self) -> ~str {`
`124`		`- format!("{:u}:{:u} {:?}", self.location.line, self.location.column, self.reason)`
	`123`	`+impl fmt::Show for SyntaxError {`
	`124`	`+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {`
	`125`	`+ write!(f.buf, "{:u}:{:u} {:?}", self.location.line, self.location.column, self.reason)`
`125`	`126`	`}`
`126`	`127`	`}`
`127`	`128`
`@@ -138,7 +139,7 @@ impl<'a> SkipWhitespaceIterable<'a> for &'a [ComponentValue] {`
`138`	`139`
`139`	`140`	`#[deriving(Clone)]`
`140`	`141`	`pub struct SkipWhitespaceIterator<'a> {`
`141`		`- iter_with_whitespace: vec::VecIterator<'a, ComponentValue>,`
	`142`	`+ iter_with_whitespace: vec::Items<'a, ComponentValue>,`
`142`	`143`	`}`
`143`	`144`
`144`	`145`	`impl<'a> Iterator<&'a ComponentValue> for SkipWhitespaceIterator<'a> {`
`@@ -162,7 +163,7 @@ impl MoveSkipWhitespaceIterable for ~[ComponentValue] {`
`162`	`163`	`}`
`163`	`164`
`164`	`165`	`pub struct MoveSkipWhitespaceIterator {`
`165`		`- iter_with_whitespace: vec::MoveIterator<ComponentValue>,`
	`166`	`+ iter_with_whitespace: vec::MoveItems<ComponentValue>,`
`166`	`167`	`}`
`167`	`168`
`168`	`169`	`impl Iterator<ComponentValue> for MoveSkipWhitespaceIterator {`