inline: parse multiline attributes

reimplement after broken by "take str per line instead of full inline
iter" commit

also resolves #18

src/attr.rs

@@ -44,6 +44,18 @@ impl<'s> AttributeValue<'s> {
     pub fn parts(&'s self) -> AttributeValueParts<'s> {
         AttributeValueParts { ahead: &self.raw }
     }
+
+    fn extend(&mut self, s: &'s str) {
+        match &mut self.raw {
+            CowStr::Borrowed(prev) => {
+                self.raw = format!("{} {}", prev, s).into();
+            }
+            CowStr::Owned(ref mut prev) => {
+                prev.push(' ');
+                prev.push_str(s);
+            }
+        }
+    }
 }
 
 impl<'s> From<&'s str> for AttributeValue<'s> {
@@ -233,6 +245,18 @@ impl<'a, 's> Parser<'a, 's> {
         }
     }
 
+    pub fn restart(&mut self) {
+        self.state = State::Start;
+    }
+
+    pub fn set_input(&mut self, input: &'s str) {
+        debug_assert_eq!(self.chars.next(), None);
+        self.input = input;
+        self.chars = input.chars();
+        self.pos = 0;
+        self.pos_prev = 0;
+    }
+
     pub fn step(&mut self) -> StepResult {
         self.chars.next().map_or(StepResult::More, |c| {
             use State::*;
@@ -272,12 +296,14 @@ impl<'a, 's> Parser<'a, 's> {
                 Some((Element::Key, sp)) => self.span_key = Some(sp),
                 Some((Element::Value { continuation }, sp)) => {
                     if continuation {
-                        self.attrs.0.as_mut().unwrap().last_mut().unwrap().1 = format!(
-                            "{} {}",
-                            self.attrs.0.as_ref().unwrap().last().unwrap().1,
-                            sp.of(self.input),
-                        )
-                        .into();
+                        self.attrs
+                            .0
+                            .as_mut()
+                            .unwrap()
+                            .last_mut()
+                            .unwrap()
+                            .1
+                            .extend(sp.of(self.input));
                     } else {
                         self.attrs.insert(
                             self.span_key.take().unwrap().of(self.input),
@@ -295,6 +321,10 @@ impl<'a, 's> Parser<'a, 's> {
             }
         })
     }
+
+    pub fn len(&self) -> usize {
+        self.input.len() - self.chars.as_str().len()
+    }
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]