Expand vendor prefixes from bitflags

Author: devongovett

src/declaration.rs

@@ -33,12 +33,7 @@ impl Declaration {
 
 impl ToCss for Declaration {
   fn to_css<W>(&self, dest: &mut Printer<W>) -> std::fmt::Result where W: std::fmt::Write {
-    self.property.to_css(dest)?;
-    if self.important {
-      dest.whitespace()?;
-      dest.write_str("!important")?;
-    }
-    Ok(())
+    self.property.to_css(dest, self.important)
   }
 }
 

src/properties/mod.rs

@@ -32,6 +32,7 @@ use crate::traits::{Parse, ToCss};
 use crate::printer::Printer;
 use smallvec::{SmallVec, smallvec};
 use bitflags::bitflags;
+use std::fmt::Write;
 
 bitflags! {
   pub struct VendorPrefix: u8 {
@@ -109,24 +110,70 @@ macro_rules! define_properties {
         return Ok(Property::Custom(CustomProperty::parse(name, input)?))
       }
 
-      pub fn to_css<W>(&self, dest: &mut Printer<W>) -> std::fmt::Result where W: std::fmt::Write {
+      pub fn to_css<W>(&self, dest: &mut Printer<W>, important: bool) -> std::fmt::Result where W: std::fmt::Write {
         use Property::*;
 
         match self {
           $(
             $property(val, $($vp)?) => {
-              $($vp.to_css(dest)?;)?
-              dest.write_str($name)?;
-              dest.delim(':', false)?;
-              val.to_css(dest)
+              // If there are multiple vendor prefixes set, this expands them.
+              let mut first = true;
+              macro_rules! start {
+                () => {
+                  if first {
+                    first = false;
+                  } else {
+                    dest.write_char(';')?;
+                    if !dest.minify {
+                      dest.write_str("\n  ")?;
+                    }
+                  }
+                };
+              }
+
+              macro_rules! write {
+                () => {
+                  dest.write_str($name)?;
+                  dest.delim(':', false)?;
+                  val.to_css(dest)?;
+                  if important {
+                    dest.whitespace()?;
+                    dest.write_str("!important")?;
+                  }
+                };
+                ($p: expr) => {
+                  start!();
+                  write!();
+                };
+                ($v: ident, $p: expr) => {
+                  if $v.contains($p) {
+                    start!();
+                    $p.to_css(dest)?;
+                    write!();
+                  }
+                };
+              }
+              
+              $(
+                write!($vp, VendorPrefix::WebKit);
+                write!($vp, VendorPrefix::Moz);
+                write!($vp, VendorPrefix::Ms);  
+              )?
+
+              write!($($vp,)? VendorPrefix::None);
             }
           )+
           Custom(custom) => {
             dest.write_str(custom.name.as_ref())?;
             dest.delim(':', false)?;
-            dest.write_str(custom.value.as_ref())
+            dest.write_str(custom.value.as_ref())?;
+            if important {
+              dest.whitespace()?;
+              dest.write_str("!important")?;
+            }
           }
         }
+        Ok(())
       }
     }
   };

src/properties/transition.rs

@@ -156,26 +156,6 @@ impl TransitionHandler {
     let mut delays = std::mem::take(&mut self.delays);
     let mut timing_functions = std::mem::take(&mut self.timing_functions);
 
-    macro_rules! expand {
-      ($prop: ident, $val: ident, $prefixes: ident) => {
-        if $prefixes.contains(VendorPrefix::WebKit) {
-          self.decls.push(Property::$prop($val.clone(), VendorPrefix::WebKit));
-        }
-
-        if $prefixes.contains(VendorPrefix::Moz) {
-          self.decls.push(Property::$prop($val.clone(), VendorPrefix::Moz));
-        }
-
-        if $prefixes.contains(VendorPrefix::Ms) {
-          self.decls.push(Property::$prop($val.clone(), VendorPrefix::Ms));
-        }
-
-        if $prefixes.contains(VendorPrefix::None) {
-          self.decls.push(Property::$prop($val, VendorPrefix::None));
-        }
-      };
-    }
-
     if let (Some((properties, property_prefixes)), Some((durations, duration_prefixes)), Some((delays, delay_prefixes)), Some((timing_functions, timing_prefixes))) = (&mut properties, &mut durations, &mut delays, &mut timing_functions) {
       // Only use shorthand syntax if the number of transitions matches on all properties.
       let len = properties.len();
@@ -189,41 +169,42 @@ impl TransitionHandler {
           }
         }).collect();
 
-        macro_rules! handle_prefix {
-          ($prefix: ident) => {
-            // If all properties have this vendor prefix, use the shorthand syntax.
-            // Otherwise, we'll fall through below to individual properties.
-            if property_prefixes.contains(VendorPrefix::$prefix) && duration_prefixes.contains(VendorPrefix::$prefix) && delay_prefixes.contains(VendorPrefix::$prefix) && timing_prefixes.contains(VendorPrefix::$prefix) {
-              self.decls.push(Property::Transition(transitions.clone(), VendorPrefix::$prefix));
-              property_prefixes.remove(VendorPrefix::$prefix);
-              duration_prefixes.remove(VendorPrefix::$prefix);
-              delay_prefixes.remove(VendorPrefix::$prefix);
-              timing_prefixes.remove(VendorPrefix::$prefix);
-            }
-          };
+        // Find the intersection of prefixes with the same value.
+        // Remove that from the prefixes of each of the properties. The remaining
+        // prefixes will be handled by outputing individual properties below.
+        let intersection = *property_prefixes & *duration_prefixes & *delay_prefixes & *timing_prefixes;
+        if !intersection.is_empty() {
+          self.decls.push(Property::Transition(transitions.clone(), intersection));
+          property_prefixes.remove(intersection);
+          duration_prefixes.remove(intersection);
+          delay_prefixes.remove(intersection);
+          timing_prefixes.remove(intersection);
         }
-
-        handle_prefix!(WebKit);
-        handle_prefix!(Moz);
-        handle_prefix!(Ms);
-        handle_prefix!(None);
       }
     }
 
     if let Some((properties, prefix)) = properties {
-      expand!(TransitionProperty, properties, prefix);
+      if !prefix.is_empty() {
+        self.decls.push(Property::TransitionProperty(properties, prefix));
+      }
     }
 
     if let Some((durations, prefix)) = durations {
-      expand!(TransitionDuration, durations, prefix);
+      if !prefix.is_empty() {
+        self.decls.push(Property::TransitionDuration(durations, prefix));
+      }
     }
 
     if let Some((delays, prefix)) = delays {
-      expand!(TransitionDelay, delays, prefix);
+      if !prefix.is_empty() {
+        self.decls.push(Property::TransitionDelay(delays, prefix));
+      }
     }
 
     if let Some((timing_functions, prefix)) = timing_functions {
-      expand!(TransitionTimingFunction, timing_functions, prefix);
+      if !prefix.is_empty() {
+        self.decls.push(Property::TransitionTimingFunction(timing_functions, prefix));
+      }
     }
 
     self.reset();