Fixed #3 (semicolon in attributes)

Also some refactorings.

Author: netvl

src/common.rs

@@ -5,7 +5,7 @@ use std::fmt;
 /// XML parsing error.
 ///
 /// Consists of a row and column reference and a message.
-#[deriving(Clone, PartialEq)]
+#[deriving(Clone, PartialEq, Eq)]
 pub struct Error {
     row: uint,
     col: uint,
@@ -61,7 +61,7 @@ impl Error {
 ///
 /// Consists of optional prefix, optional namespace and mandatory
 /// local name.
-#[deriving(Clone, PartialEq)]
+#[deriving(Clone, PartialEq, Eq)]
 pub struct Name {
     /// An XML namespace prefix.
     ///
@@ -97,6 +97,16 @@ impl fmt::Show for Name {
 }
 
 impl Name {
+    /// Returns a `Name` instance representing plain local name.
+    #[inline]
+    pub fn new_local(name: &str) -> Name {
+        Name {
+            local_name: name.to_string(),
+            prefix: None,
+            namespace: None
+        }
+    }
+
     /// Returns a slice with namespace prefix of this name, if it is present.
     pub fn prefix_ref<'a>(&'a self) -> Option<&'a str> {
         match self.prefix {
@@ -124,7 +134,7 @@ impl Name {
 /// XML element attribute.
 ///
 /// Consistes of a qualified name and a value.
-#[deriving(Clone, PartialEq)]
+#[deriving(Clone, PartialEq, Eq)]
 pub struct Attribute {
     /// Qualified name of the attribute.
     pub name: Name,
@@ -133,8 +143,17 @@ pub struct Attribute {
     pub value: String
 }
 
+impl Attribute {
+    pub fn new_local(name: &str, value: &str) -> Attribute {
+        Attribute {
+            name: Name::new_local(name),
+            value: value.to_string()
+        }
+    }
+}
+
 /// XML version enumeration.
-#[deriving(Clone, PartialEq)]
+#[deriving(Clone, PartialEq, Eq)]
 pub enum XmlVersion {
     /// XML version 1.0.
     Version10,

src/namespace.rs

@@ -25,8 +25,31 @@ pub struct Namespace(pub HashMap<Option<String>, String>);
 
 impl Namespace {
     /// Returns an empty namespace.
+    #[inline]
     pub fn empty() -> Namespace { Namespace(HashMap::with_capacity(2)) }
 
+    /// Checks whether this namespace is empty.
+    #[inline]
+    pub fn is_empty(&self) -> bool {
+        let Namespace(ref hm) = *self;
+        hm.is_empty()
+    }
+
+    /// Checks whether this namespace is essentially empty, that is, it does not contain
+    /// anything but default mappings.
+    pub fn is_essentially_empty(&self) -> bool {
+        let Namespace(ref hm) = *self;
+        for (k, v) in hm.iter() {
+            match (k.as_ref().map(|k| k.as_slice()), v.as_slice()) {
+                (None, NS_EMPTY_URI) |
+                (Some(NS_XMLNS_PREFIX), NS_XMLNS_URI) |
+                (Some(NS_XML_PREFIX), NS_XML_URI) => {},
+                _ => return false
+            }
+        }
+        true
+    }
+
     /// Puts a mapping into this namespace.
     ///
     /// This method does not override already existing mapping.

src/reader/mod.rs

@@ -32,7 +32,7 @@ impl<B: Buffer> EventReader<B> {
     /// Creates a new parser with the provded configuration, consuming given `Buffer`.
     #[inline]
     pub fn new_with_config(source: B, config: ParserConfig) -> EventReader<B> {
-        EventReader { source: source, parser: parser::new(config) }
+        EventReader { source: source, parser: PullParser::new(config) }
     }
 
     /// Pulls and returns next XML event from the stream.

src/reader/parser.rs

@@ -61,35 +61,37 @@ pub struct PullParser {
     pop_namespace: bool
 }
 
-/// Returns a new parser using the given config.
-pub fn new(config: ParserConfig) -> PullParser {
-    PullParser {
-        config: config,
-        lexer: lexer::new(),
-        st: OutsideTag,
-        buf: String::new(),
-        nst: NamespaceStack::default(),
-
-        data: MarkupData {
-            name: String::new(),
-            version: None,
-            encoding: None,
-            standalone: None,
-            ref_data: String::new(),
-            element_name: None,
-            quote: None,
-            attr_name: None,
-            attributes: vec!()
-        },
-        finish_event: None,
-        next_event: None,
-        est: Vec::new(),
-
-        encountered_element: false,
-        parsed_declaration: false,
-        inside_whitespace: true,
-        read_prefix_separator: false,
-        pop_namespace: false
+impl PullParser {
+    /// Returns a new parser using the given config.
+    pub fn new(config: ParserConfig) -> PullParser {
+        PullParser {
+            config: config,
+            lexer: lexer::new(),
+            st: OutsideTag,
+            buf: String::new(),
+            nst: NamespaceStack::default(),
+
+            data: MarkupData {
+                name: String::new(),
+                version: None,
+                encoding: None,
+                standalone: None,
+                ref_data: String::new(),
+                element_name: None,
+                quote: None,
+                attr_name: None,
+                attributes: vec!()
+            },
+            finish_event: None,
+            next_event: None,
+            est: Vec::new(),
+
+            encountered_element: false,
+            parsed_declaration: false,
+            inside_whitespace: true,
+            read_prefix_separator: false,
+            pop_namespace: false
+        }
     }
 }
 
@@ -159,6 +161,29 @@ enum QualifiedNameTarget {
     ClosingTagNameTarget
 }
 
+#[deriving(PartialEq, Eq)]
+enum QuoteToken {
+    SingleQuoteToken,
+    DoubleQuoteToken
+}
+
+impl QuoteToken {
+    fn from_token(t: &Token) -> QuoteToken {
+        match *t {
+            SingleQuote => SingleQuoteToken,
+            DoubleQuote => DoubleQuoteToken,
+            _ => fail!("Unexpected token: {}", t)
+        }
+    }
+
+    fn as_token(self) -> Token {
+        match self {
+            SingleQuoteToken => SingleQuote,
+            DoubleQuoteToken => DoubleQuote
+        }
+    }
+}
+
 struct AttributeData {
     name: Name,
     value: String
@@ -184,7 +209,7 @@ struct MarkupData {
 
     element_name: Option<Name>,  // used for element name
 
-    quote: Option<Token>,  // used to hold opening quote for attribute value
+    quote: Option<QuoteToken>,  // used to hold opening quote for attribute value
     attr_name: Option<Name>,  // used to hold attribute name
     attributes: Vec<AttributeData>   // used to hold all accumulated attributes
 }
@@ -397,12 +422,12 @@ impl PullParser {
         match t {
             Whitespace(_) if self.data.quote.is_none() => None,  // skip leading whitespace
 
-            DoubleQuote | SingleQuote => match self.data.quote.clone() {
+            DoubleQuote | SingleQuote => match self.data.quote {
                 None => {  // Entered attribute value
-                    self.data.quote = Some(t);
+                    self.data.quote = Some(QuoteToken::from_token(&t));
                     None
                 }
-                Some(ref q) if *q == t => {
+                Some(q) if q.as_token() == t => {
                     self.data.quote = None;
                     let value = self.take_buf();
                     on_value(self, value)
@@ -415,10 +440,8 @@ impl PullParser {
                 self.into_state_continue(InsideReference(st))
             }
 
-            // Everything characters except " and '
-            _ if t.contains_char_data() => self.append_str_continue(t.to_string().as_slice()),
-
-            _ => Some(self_error!(self; "Unexpected token inside attribute value: {}", t))
+            // Every character except " and ' is okay
+            _  => self.append_str_continue(t.to_string().as_slice()),
         }
     }
 
@@ -1026,4 +1049,49 @@ impl PullParser {
 
 #[cfg(test)]
 mod tests {
+    use std::io::BufReader;
+
+    use common::{Name, Attribute};
+    use reader::parser::PullParser;
+    use reader::ParserConfig;
+    use reader::events;
+
+    fn new_parser() -> PullParser {
+        PullParser::new(ParserConfig::new())
+    }
+
+    macro_rules! expect_event(
+        ($r:expr, $p:expr, $t:pat) => (
+            match $p.next(&mut $r) {
+                $t => {}
+                e => fail!("Unexpected event: {}", e)
+            }
+        );
+        ($r:expr, $p:expr, $t:pat if $c:expr) => (
+            match $p.next(&mut $r) {
+                $t if $c => {}
+                e => fail!("Unexpected event: {}", e)
+            }
+        )
+    )
+
+    #[test]
+    fn semicolon_in_attribute_issue_3() {
+        static DATA: &'static str = r#"
+            <a attr="zzz;zzz" />
+        "#;
+        let mut r = BufReader::new(DATA.as_bytes());
+
+        let mut p = new_parser();
+        
+        expect_event!(r, p, events::StartDocument { .. });
+        expect_event!(r, p, events::StartElement { ref name, ref attributes, ref namespace }
+            if *name == Name::new_local("a") &&
+               attributes.len() == 1 && 
+               attributes[0] == Attribute::new_local("attr", "zzz;zzz") &&
+               namespace.is_essentially_empty()
+        );
+        expect_event!(r, p, events::EndElement { ref name } if *name == Name::new_local("a"));
+        expect_event!(r, p, events::EndDocument);
+    }
 }