Implement rem() and mod() functions

Author: devongovett

src/lib.rs

@@ -5996,6 +5996,19 @@ mod tests {
     );
     minify_test(".foo { margin: round(to-zero, -23px, 5px) }", ".foo{margin:-20px}");
     minify_test(".foo { margin: round(nearest, -23px, 5px) }", ".foo{margin:-25px}");
+    minify_test(".foo { width: rem(18px, 5px) }", ".foo{width:3px}");
+    minify_test(".foo { width: rem(-18px, 5px) }", ".foo{width:-3px}");
+    minify_test(".foo { width: rem(18px, 5vw) }", ".foo{width:rem(18px,5vw)}");
+    minify_test(".foo { rotate: rem(-140deg, -90deg) }", ".foo{rotate:-50deg}");
+    minify_test(".foo { rotate: rem(140deg, -90deg) }", ".foo{rotate:50deg}");
+    minify_test(".foo { width: mod(18px, 5px) }", ".foo{width:3px}");
+    minify_test(".foo { width: mod(-18px, 5px) }", ".foo{width:2px}");
+    minify_test(".foo { rotate: mod(-140deg, -90deg) }", ".foo{rotate:-50deg}");
+    minify_test(".foo { rotate: mod(140deg, -90deg) }", ".foo{rotate:-40deg}");
+    minify_test(
+      ".foo { transform: rotateX(mod(140deg, -90deg)) rotateY(rem(140deg, -90deg)) }",
+      ".foo{transform:rotateX(-40deg)rotateY(50deg)}",
+    );
   }
 
   #[test]

src/values/angle.rs

@@ -205,6 +205,20 @@ impl Round for Angle {
   }
 }
 
+impl std::ops::Rem for Angle {
+  type Output = Angle;
+
+  fn rem(self, rhs: Self) -> Self::Output {
+    match (self, rhs) {
+      (Angle::Deg(a), Angle::Deg(b)) => Angle::Deg(a % b),
+      (Angle::Rad(a), Angle::Rad(b)) => Angle::Rad(a % b),
+      (Angle::Grad(a), Angle::Grad(b)) => Angle::Grad(a % b),
+      (Angle::Turn(a), Angle::Turn(b)) => Angle::Turn(a % b),
+      (a, b) => Angle::Deg(a.to_degrees() % b.to_degrees()),
+    }
+  }
+}
+
 /// A CSS [`<angle-percentage>`](https://www.w3.org/TR/css-values-4/#typedef-angle-percentage) value.
 /// May be specified as either an angle or a percentage that resolves to an angle.
 pub type AnglePercentage = DimensionPercentage<Angle>;

src/values/calc.rs

@@ -31,6 +31,10 @@ pub enum MathFunction<V> {
   Clamp(Calc<V>, Calc<V>, Calc<V>),
   /// The [`round()`](https://www.w3.org/TR/css-values-4/#funcdef-round) function.
   Round(RoundingStrategy, Calc<V>, Calc<V>),
+  /// The [`rem()`](https://www.w3.org/TR/css-values-4/#funcdef-rem) function.
+  Rem(Calc<V>, Calc<V>),
+  /// The [`mod()`](https://www.w3.org/TR/css-values-4/#funcdef-mod) function.
+  Mod(Calc<V>, Calc<V>),
 }
 
 enum_property! {
@@ -72,6 +76,18 @@ impl<T: Round> TryRound for T {
   }
 }
 
+/// A trait for values that potentially support a remainder (e.g. if they have the same unit).
+pub trait TryRem: Sized {
+  /// Returns the remainder between two values, if possible.
+  fn try_rem(&self, rhs: &Self) -> Option<Self>;
+}
+
+impl<T: std::ops::Rem<T, Output = T> + Clone> TryRem for T {
+  fn try_rem(&self, rhs: &Self) -> Option<Self> {
+    Some(self.clone() % rhs.clone())
+  }
+}
+
 impl<V: ToCss + std::cmp::PartialOrd<f32> + std::ops::Mul<f32, Output = V> + Clone + std::fmt::Debug> ToCss
   for MathFunction<V>
 {
@@ -146,6 +162,20 @@ impl<V: ToCss + std::cmp::PartialOrd<f32> + std::ops::Mul<f32, Output = V> + Clo
         b.to_css(dest)?;
         dest.write_char(')')
       }
+      MathFunction::Rem(a, b) => {
+        dest.write_str("rem(")?;
+        a.to_css(dest)?;
+        dest.delim(',', false)?;
+        b.to_css(dest)?;
+        dest.write_char(')')
+      }
+      MathFunction::Mod(a, b) => {
+        dest.write_str("mod(")?;
+        a.to_css(dest)?;
+        dest.delim(',', false)?;
+        b.to_css(dest)?;
+        dest.write_char(')')
+      }
     }
   }
 }
@@ -179,9 +209,11 @@ impl<
       + std::ops::Mul<f32, Output = V>
       + AddInternal
       + TryRound
+      + TryRem
       + std::cmp::PartialOrd<V>
       + std::convert::Into<Calc<V>>
       + std::convert::From<Calc<V>>
+      + Clone
       + std::fmt::Debug,
   > Parse<'i> for Calc<V>
 {
@@ -289,6 +321,38 @@ impl<
           Ok(Calc::Function(Box::new(MathFunction::Round(strategy, a, b))))
         })
       },
+      "rem" => {
+        input.parse_nested_block(|input| {
+          let a: Calc<V> = Calc::parse_sum(input)?;
+          input.expect_comma()?;
+          let b: Calc<V> = Calc::parse_sum(input)?;
+
+          if let (Calc::Value(a), Calc::Value(b)) = (&a, &b) {
+            if let Some(rem) = a.try_rem(&**b) {
+              return Ok(Calc::Value(Box::new(rem)))
+            }
+          }
+
+          Ok(Calc::Function(Box::new(MathFunction::Rem(a, b))))
+        })
+      },
+      "mod" => {
+        input.parse_nested_block(|input| {
+          let a: Calc<V> = Calc::parse_sum(input)?;
+          input.expect_comma()?;
+          let b: Calc<V> = Calc::parse_sum(input)?;
+
+          if let (Calc::Value(a), Calc::Value(b)) = (&a, &b) {
+            // ((a % b) + b) % b
+            if let Some(rem) = a.try_rem(&**b) {
+              let rem = rem.add((**b).clone()).try_rem(b).unwrap();
+              return Ok(Calc::Value(Box::new(rem)))
+            }
+          }
+
+          Ok(Calc::Function(Box::new(MathFunction::Rem(a, b))))
+        })
+      },
       _ => Err(location.new_unexpected_token_error(Token::Ident(f.clone()))),
     }
   }
@@ -300,9 +364,11 @@ impl<
       + std::ops::Mul<f32, Output = V>
       + AddInternal
       + TryRound
+      + TryRem
       + std::cmp::PartialOrd<V>
       + std::convert::Into<Calc<V>>
       + std::convert::From<Calc<V>>
+      + Clone
       + std::fmt::Debug,
   > Calc<V>
 {

src/values/length.rs

@@ -1,6 +1,6 @@
 //! CSS length values.
 
-use super::calc::{Calc, MathFunction, Round, RoundingStrategy, TryRound};
+use super::calc::{Calc, MathFunction, Round, RoundingStrategy, TryRem, TryRound};
 use super::number::CSSNumber;
 use super::percentage::DimensionPercentage;
 use crate::error::{ParserError, PrinterError};
@@ -225,6 +225,24 @@ macro_rules! define_length_units {
         }
       }
     }
+
+    impl TryRem for LengthValue {
+      fn try_rem(&self, rhs: &Self) -> Option<Self> {
+        use LengthValue::*;
+        match (self, rhs) {
+          $(
+            ($name(a), $name(b)) => Some($name(a % b)),
+          )+
+          (a, b) => {
+            if let (Some(a), Some(b)) = (a.to_px(), b.to_px()) {
+              Some(Px(a % b))
+            } else {
+              None
+            }
+          }
+        }
+      }
+    }
   };
 }
 
@@ -655,6 +673,15 @@ impl TryRound for Length {
   }
 }
 
+impl TryRem for Length {
+  fn try_rem(&self, rhs: &Self) -> Option<Self> {
+    match (self, rhs) {
+      (Length::Value(a), Length::Value(b)) => a.try_rem(b).map(Length::Value),
+      _ => None,
+    }
+  }
+}
+
 /// Either a [`<length>`](https://www.w3.org/TR/css-values-4/#lengths) or a [`<number>`](https://www.w3.org/TR/css-values-4/#numbers).
 #[derive(Debug, Clone, PartialEq)]
 #[cfg_attr(

src/values/percentage.rs

@@ -1,6 +1,6 @@
 //! CSS percentage values.
 
-use super::calc::{Calc, MathFunction, Round, RoundingStrategy, TryRound};
+use super::calc::{Calc, MathFunction, Round, RoundingStrategy, TryRem, TryRound};
 use super::number::CSSNumber;
 use crate::error::{ParserError, PrinterError};
 use crate::printer::Printer;
@@ -123,6 +123,14 @@ impl Round for Percentage {
   }
 }
 
+impl std::ops::Rem for Percentage {
+  type Output = Percentage;
+
+  fn rem(self, rhs: Self) -> Self::Output {
+    Percentage(self.0 % rhs.0)
+  }
+}
+
 /// Either a `<number>` or `<percentage>`.
 #[derive(Debug, Clone, PartialEq)]
 #[cfg_attr(
@@ -207,6 +215,7 @@ impl<
       + TryAdd<D>
       + Clone
       + TryRound
+      + TryRem
       + std::cmp::PartialEq<CSSNumber>
       + std::cmp::PartialOrd<CSSNumber>
       + std::cmp::PartialOrd<D>
@@ -439,6 +448,20 @@ impl<D: TryRound> TryRound for DimensionPercentage<D> {
   }
 }
 
+impl<D: TryRem> TryRem for DimensionPercentage<D> {
+  fn try_rem(&self, rhs: &Self) -> Option<Self> {
+    match (self, rhs) {
+      (DimensionPercentage::Dimension(a), DimensionPercentage::Dimension(b)) => {
+        a.try_rem(b).map(DimensionPercentage::Dimension)
+      }
+      (DimensionPercentage::Percentage(a), DimensionPercentage::Percentage(b)) => {
+        Some(DimensionPercentage::Percentage(a.clone() % b.clone()))
+      }
+      _ => None,
+    }
+  }
+}
+
 impl<
     D: ToCss + std::cmp::PartialOrd<CSSNumber> + std::ops::Mul<CSSNumber, Output = D> + Clone + std::fmt::Debug,
   > ToCss for DimensionPercentage<D>

src/values/time.rs

@@ -166,3 +166,16 @@ impl Round for Time {
     }
   }
 }
+
+impl std::ops::Rem for Time {
+  type Output = Time;
+
+  fn rem(self, rhs: Self) -> Self::Output {
+    match (self, rhs) {
+      (Time::Seconds(a), Time::Seconds(b)) => Time::Seconds(a % b),
+      (Time::Milliseconds(a), Time::Milliseconds(b)) => Time::Milliseconds(a % b),
+      (Time::Seconds(a), Time::Milliseconds(b)) => Time::Seconds(a % (b / 1000.0)),
+      (Time::Milliseconds(a), Time::Seconds(b)) => Time::Seconds(a % (b * 1000.0)),
+    }
+  }
+}