[librsvg: 1/23] Evaluate conditional processing attributes at rendering time

[Federico Mena Quintero <federico src gnome org>]

commit f50436fc265e1afcbcfa59042bca3a8b330fd32e
Author: Federico Mena Quintero <federico gnome org>
Date:   Mon May 17 20:07:55 2021 -0500

    Evaluate conditional processing attributes at rendering time
    
    Instead of storing a `cond: bool` field in Element, we store
    individual fields for RequiredExtensions / RequiredFeatures /
    SystemLanguage.
    
    Then, element.get_cond() calls a new eval() method on each of those
    fields.  This last step is done at rendering time, when the <switch>
    element is being rendered.

 src/cond.rs    | 20 ++++++++++++++++++--
 src/element.rs | 48 +++++++++++++++++++++++++++++-------------------
 2 files changed, 47 insertions(+), 21 deletions(-)
---
diff --git a/src/cond.rs b/src/cond.rs
index b29039a3..5d5a7043 100644
--- a/src/cond.rs
+++ b/src/cond.rs
@@ -17,14 +17,20 @@ static IMPLEMENTED_EXTENSIONS: &[&str] = &[];
 pub struct RequiredExtensions(pub bool);
 
 impl RequiredExtensions {
-    // Parse a requiredExtensions attribute
-    // http://www.w3.org/TR/SVG/struct.html#RequiredExtensionsAttribute
+    /// Parse a requiredExtensions attribute.
+    ///
+    /// http://www.w3.org/TR/SVG/struct.html#RequiredExtensionsAttribute
     pub fn from_attribute(s: &str) -> Result<RequiredExtensions, ValueErrorKind> {
         Ok(RequiredExtensions(
             s.split_whitespace()
                 .all(|f| IMPLEMENTED_EXTENSIONS.binary_search(&f).is_ok()),
         ))
     }
+
+    /// Evaluate a requiredExtensions value for conditional processing.
+    pub fn eval(&self) -> bool {
+        self.0
+    }
 }
 
 // Keep these sorted alphabetically for binary_search.
@@ -64,6 +70,11 @@ impl RequiredFeatures {
                 .all(|f| IMPLEMENTED_FEATURES.binary_search(&f).is_ok()),
         ))
     }
+
+    /// Evaluate a requiredFeatures value for conditional processing.
+    pub fn eval(&self) -> bool {
+        self.0
+    }
 }
 
 #[derive(Debug, PartialEq)]
@@ -110,6 +121,11 @@ impl SystemLanguage {
                 },
             )
     }
+
+    /// Evaluate a systemLanguage value for conditional processing.
+    pub fn eval(&self) -> bool {
+        self.0
+    }
 }
 
 fn locale_accepts_language_tag(
diff --git a/src/element.rs b/src/element.rs
index 3c68804d..3154c321 100644
--- a/src/element.rs
+++ b/src/element.rs
@@ -104,7 +104,9 @@ pub struct ElementInner<T: SetAttributes + Draw> {
     result: ElementResult,
     transform: Transform,
     values: ComputedValues,
-    cond: bool,
+    required_extensions: Option<RequiredExtensions>,
+    required_features: Option<RequiredFeatures>,
+    system_language: Option<SystemLanguage>,
     pub element_impl: T,
 }
 
@@ -127,7 +129,9 @@ impl<T: SetAttributes + Draw> ElementInner<T> {
             result,
             transform: Default::default(),
             values: Default::default(),
-            cond: true,
+            required_extensions: Default::default(),
+            required_features: Default::default(),
+            system_language: Default::default(),
             element_impl,
         };
 
@@ -174,7 +178,20 @@ impl<T: SetAttributes + Draw> ElementInner<T> {
     }
 
     fn get_cond(&self) -> bool {
-        self.cond
+        self.required_extensions
+            .as_ref()
+            .map(|v| v.eval())
+            .unwrap_or(true)
+            && self
+                .required_features
+                .as_ref()
+                .map(|v| v.eval())
+                .unwrap_or(true)
+            && self
+                .system_language
+                .as_ref()
+                .map(|v| v.eval())
+                .unwrap_or(true)
     }
 
     fn get_transform(&self) -> Transform {
@@ -193,34 +210,27 @@ impl<T: SetAttributes + Draw> ElementInner<T> {
     }
 
     fn set_conditional_processing_attributes(&mut self) -> Result<(), ElementError> {
-        let mut cond = self.cond;
-
         for (attr, value) in self.attributes.iter() {
             match attr.expanded() {
-                expanded_name!("", "requiredExtensions") if cond => {
-                    cond = RequiredExtensions::from_attribute(value)
-                        .map(|RequiredExtensions(res)| res)
-                        .attribute(attr)?;
+                expanded_name!("", "requiredExtensions") => {
+                    self.required_extensions =
+                        Some(RequiredExtensions::from_attribute(value).attribute(attr)?);
                 }
 
-                expanded_name!("", "requiredFeatures") if cond => {
-                    cond = RequiredFeatures::from_attribute(value)
-                        .map(|RequiredFeatures(res)| res)
-                        .attribute(attr)?;
+                expanded_name!("", "requiredFeatures") => {
+                    self.required_features =
+                        Some(RequiredFeatures::from_attribute(value).attribute(attr)?);
                 }
 
-                expanded_name!("", "systemLanguage") if cond => {
-                    cond = SystemLanguage::from_attribute(value, &LOCALE)
-                        .map(|SystemLanguage(res)| res)
-                        .attribute(attr)?;
+                expanded_name!("", "systemLanguage") => {
+                    self.system_language =
+                        Some(SystemLanguage::from_attribute(value, &LOCALE).attribute(attr)?);
                 }
 
                 _ => {}
             }
         }
 
-        self.cond = cond;
-
         Ok(())
     }