moved css longhand counter-reset out of mako

components/style/values/computed/counters.rs

@@ -0,0 +1,80 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * 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/. */
+
+//! Computed values for counter properties
+
+use values::CustomIdent;
+use values::computed::{Context, ToComputedValue};
+use values::generics::counters::CounterIntegerList;
+use values::specified::{CounterIncrement as SpecifiedCounterIncrement, CounterReset as SpecifiedCounterReset};
+
+type ComputedIntegerList = CounterIntegerList<i32>;
+
+/// A computed value for the `counter-increment` property.
+#[derive(Clone, Debug, MallocSizeOf, PartialEq, ToCss)]
+pub struct CounterIncrement(pub ComputedIntegerList);
+
+impl CounterIncrement {
+    /// Returns the `none` value.
+    #[inline]
+    pub fn none() -> CounterIncrement {
+        CounterIncrement(ComputedIntegerList::new(Vec::new()))
+    }
+
+    /// Returns a new computed `counter-increment` object with the given values.
+    pub fn new(vec: Vec<(CustomIdent, i32)>) -> CounterIncrement {
+        CounterIncrement(ComputedIntegerList::new(vec))
+    }
+
+    /// Returns the values of the computed `counter-increment` object.
+    pub fn get_values(&self) -> &[(CustomIdent, i32)] {
+        self.0.get_values()
+    }
+}
+
+impl ToComputedValue for SpecifiedCounterIncrement {
+    type ComputedValue = CounterIncrement;
+
+    fn to_computed_value(&self, context: &Context) -> Self::ComputedValue {
+        CounterIncrement(self.0.to_computed_value(context))
+    }
+
+    fn from_computed_value(computed: &Self::ComputedValue) -> Self {
+        SpecifiedCounterIncrement(ToComputedValue::from_computed_value(&computed.0))
+    }
+}
+
+/// A computed value for the `counter-reset` property.
+#[derive(Clone, Debug, MallocSizeOf, PartialEq, ToCss)]
+pub struct CounterReset(pub ComputedIntegerList);
+
+impl CounterReset {
+    /// Returns the `none` value.
+    #[inline]
+    pub fn none() -> CounterReset {
+        CounterReset(ComputedIntegerList::new(Vec::new()))
+    }
+
+    /// Returns a new computed `counter-reset` object with the given values.
+    pub fn new(vec: Vec<(CustomIdent, i32)>) -> CounterReset {
+        CounterReset(ComputedIntegerList::new(vec))
+    }
+
+    /// Returns the values of the computed `counter-reset` object.
+    pub fn get_values(&self) -> &[(CustomIdent, i32)] {
+        self.0.get_values()
+    }
+}
+
+impl ToComputedValue for SpecifiedCounterReset {
+    type ComputedValue = CounterReset;
+
+    fn to_computed_value(&self, context: &Context) -> Self::ComputedValue {
+        CounterReset(self.0.to_computed_value(context))
+    }
+
+    fn from_computed_value(computed: &Self::ComputedValue) -> Self {
+        SpecifiedCounterReset(ToComputedValue::from_computed_value(&computed.0))
+    }
+}

components/style/values/computed/mod.rs

@@ -46,6 +46,7 @@ pub use self::font::{MozScriptLevel, MozScriptMinSize, MozScriptSizeMultiplier,
 pub use self::box_::{AnimationIterationCount, AnimationName, Display, OverscrollBehavior, Contain};
 pub use self::box_::{OverflowClipBox, ScrollSnapType, TouchAction, VerticalAlign, WillChange};
 pub use self::color::{Color, ColorPropertyValue, RGBAColor};
+pub use self::counters::{CounterIncrement, CounterReset};
 pub use self::effects::{BoxShadow, Filter, SimpleShadow};
 pub use self::flex::FlexBasis;
 pub use self::image::{Gradient, GradientItem, Image, ImageLayer, LineDirection, MozImageRect};
@@ -86,6 +87,7 @@ pub mod border;
 #[path = "box.rs"]
 pub mod box_;
 pub mod color;
+pub mod counters;
 pub mod effects;
 pub mod flex;
 pub mod font;

components/style/values/generics/counters.rs

@@ -5,26 +5,37 @@
 //! Generic types for counters-related CSS values.
 
 use std::fmt;
+use std::fmt::Write;
 use style_traits::{CssWriter, ToCss};
 use values::CustomIdent;
 
-/// A generic value for the `counter-increment` property.
+/// A generic value for both the `counter-increment` and `counter-reset` property.
 ///
-/// Keyword `none` is represented by an empty slice.
-#[derive(Clone, Debug, PartialEq, ToComputedValue)]
-pub struct CounterIncrement<Integer>(Box<[(CustomIdent, Integer)]);
+/// Keyword `none` is represented by an empty vector.
+#[derive(Clone, Debug, MallocSizeOf, PartialEq, ToComputedValue)]
+pub struct CounterIntegerList<I>(Box<[(CustomIdent, I)]>);
 
-impl<I> CounterIncrement<I> {
-    /// Returns `none`.
+impl<I> CounterIntegerList<I> {
+    /// Returns the `none` value.
     #[inline]
-    pub fn none() -> Self {
-        CounterIncrement(vec![].into_boxed_slice())
+    pub fn none() -> CounterIntegerList<I> {
+        CounterIntegerList(vec![].into_boxed_slice())
+    }
+
+    /// Returns a new CounterIntegerList object.
+    pub fn new(vec: Vec<(CustomIdent, I)>) -> CounterIntegerList<I> {
+        CounterIntegerList(vec.into_boxed_slice())
+    }
+
+    /// Returns the values of the CounterIntegerList object.
+    pub fn get_values(&self) -> &[(CustomIdent, I)] {
+        self.0.as_ref()
     }
 }
 
-impl<I> ToCss for CounterIncrement<I>
+impl<I> ToCss for CounterIntegerList<I>
 where
-    I: ToCss,
+    I: ToCss
 {
     #[inline]
     fn to_css<W>(&self, dest: &mut CssWriter<W>) -> fmt::Result
@@ -32,12 +43,15 @@ where
         W: fmt::Write,
     {
         if self.0.is_empty() {
-            return dest.write_str("none");
+            return dest.write_str("none")
         }
-        for (&(ref name, ref value), i) in self.0.iter().enumerate() {
-            if i != 0 {
+
+        let mut first = true;
+        for &(ref name, ref value) in self.get_values() {
+            if !first {
                 dest.write_str(" ")?;
             }
+            first = false;
             name.to_css(dest)?;
             dest.write_str(" ")?;
             value.to_css(dest)?;

components/style/values/generics/mod.rs

@@ -16,6 +16,7 @@ pub mod basic_shape;
 pub mod border;
 #[path = "box.rs"]
 pub mod box_;
+pub mod counters;
 pub mod effects;
 pub mod flex;
 pub mod font;

components/style/values/specified/counters.rs

@@ -0,0 +1,102 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * 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/. */
+
+//! Specified types for counter properties.
+
+use cssparser::Parser;
+use parser::{Parse, ParserContext};
+use style_traits::ParseError;
+use values::CustomIdent;
+use values::generics::counters::CounterIntegerList;
+use values::specified::Integer;
+
+/// A specified value for the `counter-increment` and `counter-reset` property.
+type SpecifiedIntegerList = CounterIntegerList<Integer>;
+
+impl SpecifiedIntegerList {
+    fn parse_with_default<'i, 't>(
+        context: &ParserContext,
+        input: &mut Parser<'i, 't>,
+        default_value: i32
+    ) -> Result<SpecifiedIntegerList, ParseError<'i>> {
+        use cssparser::Token;
+        use style_traits::StyleParseErrorKind;
+
+        if input.try(|input| input.expect_ident_matching("none")).is_ok() {
+            return Ok(CounterIntegerList::new(Vec::new()))
+        }
+
+        let mut counters: Vec<(CustomIdent, Integer)> = Vec::new();
+        loop {
+            let location = input.current_source_location();
+            let counter_name = match input.next() {
+                Ok(&Token::Ident(ref ident)) => CustomIdent::from_ident(location, ident, &["none"])?,
+                Ok(t) => return Err(location.new_unexpected_token_error(t.clone())),
+                Err(_) => break,
+            };
+
+            let counter_delta = input.try(|input| Integer::parse(context, input))
+                                     .unwrap_or(Integer::new(default_value));
+            counters.push((counter_name, counter_delta))
+        }
+
+        if !counters.is_empty() {
+            Ok(CounterIntegerList::new(counters))
+        } else {
+            Err(input.new_custom_error(StyleParseErrorKind::UnspecifiedError))
+        }
+    }
+}
+
+/// A specified value for the `counter-increment` property.
+#[cfg_attr(feature = "gecko", derive(MallocSizeOf))]
+#[derive(Clone, Debug, PartialEq, ToCss)]
+pub struct CounterIncrement(pub SpecifiedIntegerList);
+
+impl CounterIncrement {
+    /// Returns a new specified `counter-increment` object with the given values.
+    pub fn new(vec: Vec<(CustomIdent, Integer)>) -> CounterIncrement {
+        CounterIncrement(SpecifiedIntegerList::new(vec))
+    }
+
+    /// Returns the values of the specified `counter-increment` object.
+    pub fn get_values(&self) -> &[(CustomIdent, Integer)] {
+        self.0.get_values()
+    }
+}
+
+impl Parse for CounterIncrement {
+    fn parse<'i, 't>(
+        context: &ParserContext,
+        input: &mut Parser<'i, 't>
+    ) -> Result<CounterIncrement, ParseError<'i>> {
+        Ok(CounterIncrement(SpecifiedIntegerList::parse_with_default(context, input, 1)?))
+    }
+}
+
+/// A specified value for the `counter-reset` property.
+#[cfg_attr(feature = "gecko", derive(MallocSizeOf))]
+#[derive(Clone, Debug, PartialEq, ToCss)]
+pub struct CounterReset(pub SpecifiedIntegerList);
+
+impl CounterReset {
+    /// Returns a new specified `counter-reset` object with the given values.
+    pub fn new(vec: Vec<(CustomIdent, Integer)>) -> CounterReset {
+        CounterReset(SpecifiedIntegerList::new(vec))
+    }
+
+    /// Returns the values of the specified `counter-reset` object.
+    pub fn get_values(&self) -> &[(CustomIdent, Integer)] {
+        self.0.get_values()
+    }
+}
+
+impl Parse for CounterReset {
+    fn parse<'i, 't>(
+        context: &ParserContext,
+        input: &mut Parser<'i, 't>
+    ) -> Result<CounterReset, ParseError<'i>> {
+        Ok(CounterReset(SpecifiedIntegerList::parse_with_default(context, input, 0)?))
+    }
+}

components/style/values/specified/mod.rs

@@ -40,6 +40,7 @@ pub use self::font::{MozScriptLevel, MozScriptMinSize, MozScriptSizeMultiplier,
 pub use self::box_::{AnimationIterationCount, AnimationName, Display, OverscrollBehavior, Contain};
 pub use self::box_::{OverflowClipBox, ScrollSnapType, TouchAction, VerticalAlign, WillChange};
 pub use self::color::{Color, ColorPropertyValue, RGBAColor};
+pub use self::counters::{CounterIncrement, CounterReset};
 pub use self::effects::{BoxShadow, Filter, SimpleShadow};
 pub use self::flex::FlexBasis;
 #[cfg(feature = "gecko")]
@@ -85,6 +86,7 @@ pub mod border;
 pub mod box_;
 pub mod calc;
 pub mod color;
+pub mod counters;
 pub mod effects;
 pub mod flex;
 pub mod font;