Make rules and declarations parsers take &mut self

Author: SimonSapin

Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 
 name = "cssparser"
-version = "0.6.0"
+version = "0.7.0"
 authors = [ "Simon Sapin <simon.sapin@exyr.org>" ]
 
 description = "Rust implementation of CSS Syntax Level 3"

src/rules_and_declarations.rs

@@ -69,7 +69,7 @@ pub trait DeclarationParser {
     /// If `!important` can be used in a given context,
     /// `input.try(parse_important).is_ok()` should be used at the end
     /// of the implementation of this method and the result should be part of the return value.
-    fn parse_value(&self, name: &str, input: &mut Parser) -> Result<Self::Declaration, ()>;
+    fn parse_value(&mut self, name: &str, input: &mut Parser) -> Result<Self::Declaration, ()>;
 }
 
 
@@ -106,7 +106,7 @@ pub trait AtRuleParser {
     /// The given `input` is a "delimited" parser
     /// that ends wherever the prelude should end.
     /// (Before the next semicolon, the next `{`, or the end of the current block.)
-    fn parse_prelude(&self, name: &str, input: &mut Parser)
+    fn parse_prelude(&mut self, name: &str, input: &mut Parser)
                      -> Result<AtRuleType<Self::Prelude, Self::AtRule>, ()> {
         let _ = name;
         let _ = input;
@@ -121,7 +121,7 @@ pub trait AtRuleParser {
     ///
     /// This is only called when `parse_prelude` returned `WithBlock` or `OptionalBlock`,
     /// and a block was indeed found following the prelude.
-    fn parse_block(&self, prelude: Self::Prelude, input: &mut Parser)
+    fn parse_block(&mut self, prelude: Self::Prelude, input: &mut Parser)
                    -> Result<Self::AtRule, ()> {
         let _ = prelude;
         let _ = input;
@@ -132,7 +132,7 @@ pub trait AtRuleParser {
     ///
     /// Convert the prelude into the finished representation of the at-rule
     /// as returned by `RuleListParser::next` or `DeclarationListParser::next`.
-    fn rule_without_block(&self, prelude: Self::Prelude) -> Self::AtRule {
+    fn rule_without_block(&mut self, prelude: Self::Prelude) -> Self::AtRule {
         let _ = prelude;
         panic!("The `AtRuleParser::rule_without_block` method must be overriden \
                 if `AtRuleParser::parse_prelude` ever returns `AtRuleType::OptionalBlock`.")
@@ -166,7 +166,7 @@ pub trait QualifiedRuleParser {
     ///
     /// The given `input` is a "delimited" parser
     /// that ends where the prelude should end (before the next `{`).
-    fn parse_prelude(&self, input: &mut Parser) -> Result<Self::Prelude, ()> {
+    fn parse_prelude(&mut self, input: &mut Parser) -> Result<Self::Prelude, ()> {
         let _ = input;
         Err(())
     }
@@ -176,7 +176,7 @@ pub trait QualifiedRuleParser {
     /// Return the finished representation of the qualified rule
     /// as returned by `RuleListParser::next`,
     /// or `Err(())` to ignore the entire at-rule as invalid.
-    fn parse_block(&self, prelude: Self::Prelude, input: &mut Parser)
+    fn parse_block(&mut self, prelude: Self::Prelude, input: &mut Parser)
                    -> Result<Self::QualifiedRule, ()> {
         let _ = prelude;
         let _ = input;

src/tests.rs

@@ -583,7 +583,7 @@ struct JsonParser;
 impl DeclarationParser for JsonParser {
     type Declaration = Json;
 
-    fn parse_value(&self, name: &str, input: &mut Parser) -> Result<Json, ()> {
+    fn parse_value(&mut self, name: &str, input: &mut Parser) -> Result<Json, ()> {
         let mut value = vec![];
         let mut important = false;
         loop {
@@ -622,7 +622,7 @@ impl AtRuleParser for JsonParser {
     type Prelude = Vec<Json>;
     type AtRule = Json;
 
-    fn parse_prelude(&self, name: &str, input: &mut Parser)
+    fn parse_prelude(&mut self, name: &str, input: &mut Parser)
                      -> Result<AtRuleType<Vec<Json>, Json>, ()> {
         Ok(AtRuleType::OptionalBlock(vec![
             "at-rule".to_json(),
@@ -631,12 +631,12 @@ impl AtRuleParser for JsonParser {
         ]))
     }
 
-    fn parse_block(&self, mut prelude: Vec<Json>, input: &mut Parser) -> Result<Json, ()> {
+    fn parse_block(&mut self, mut prelude: Vec<Json>, input: &mut Parser) -> Result<Json, ()> {
         prelude.push(Json::Array(component_values_to_json(input)));
         Ok(Json::Array(prelude))
     }
 
-    fn rule_without_block(&self, mut prelude: Vec<Json>) -> Json {
+    fn rule_without_block(&mut self, mut prelude: Vec<Json>) -> Json {
         prelude.push(Json::Null);
         Json::Array(prelude)
     }
@@ -646,11 +646,11 @@ impl QualifiedRuleParser for JsonParser {
     type Prelude = Vec<Json>;
     type QualifiedRule = Json;
 
-    fn parse_prelude(&self, input: &mut Parser) -> Result<Vec<Json>, ()> {
+    fn parse_prelude(&mut self, input: &mut Parser) -> Result<Vec<Json>, ()> {
         Ok(component_values_to_json(input))
     }
 
-    fn parse_block(&self, prelude: Vec<Json>, input: &mut Parser) -> Result<Json, ()> {
+    fn parse_block(&mut self, prelude: Vec<Json>, input: &mut Parser) -> Result<Json, ()> {
         Ok(JArray![
             "qualified rule",
             prelude,