svg_conform 0.2.4 → 0.2.7

data/lib/svg_conform/requirements/external_references_requirement.rb

@@ -0,0 +1,234 @@
+# frozen_string_literal: true
+
+require_relative "base_requirement"
+require_relative "../references/reference_classifier"
+require_relative "../validation/css_references"
+
+module SvgConform
+  module Requirements
+    # Rejects references that need another document, a local file or the
+    # network. Same-document fragments and self-contained image data URLs pass.
+    #
+    # Every reference goes through References::ReferenceClassifier; data URL
+    # decoding lives on References::DataUriReference. DOM and SAX validation
+    # share the same finding logic (#attribute_findings, #css_findings,
+    # #source_findings).
+    class ExternalReferencesRequirement < BaseRequirement
+      ALLOWED_DATA_TYPES = %w[image/png image/jpeg image/svg+xml].freeze
+      URL_ATTRIBUTES = %w[fill stroke filter clip-path mask marker-start
+                          marker-mid marker-end cursor].freeze
+      SVG_NAMESPACE_ROOT = "svg"
+      STYLESHEET_PI = /<\?xml-stylesheet\s(?<body>.*?)\?>/mi
+      EXTERNAL_DOCTYPE = /<!ENTITY|<!DOCTYPE[^>\[]*\b(?:SYSTEM|PUBLIC)\b/i
+
+      attribute :type, :string,
+                default: -> { "ExternalReferencesRequirement" }
+      attribute :max_data_uri_depth, :integer, default: -> { 3 }
+
+      yaml do
+        map "id", to: :id
+        map "description", to: :description
+        map "type", to: :type
+        map "citation_uri", to: :citation_uri
+        map "citation_label", to: :citation_label
+        map "max_data_uri_depth", to: :max_data_uri_depth
+      end
+
+      class State
+        attr_accessor :style_elements
+
+        def initialize
+          @style_elements = []
+        end
+      end
+
+      def needs_deferred_validation?
+        true
+      end
+
+      def check(node, context)
+        return unless element?(node)
+
+        attrs = (node.attributes || []).to_h { |a| [a.name.to_s, a.value.to_s] }
+        report_all(node, context, attribute_findings(node.name, attrs))
+        return unless local_name(node.name) == "style"
+
+        report_all(node, context, css_findings(node.text.to_s))
+      end
+
+      def collect_sax_data(element, context)
+        attrs = element.raw_attributes.to_h { |k, v| [k.to_s, v.to_s] }
+        report_all(element, context, attribute_findings(element.name, attrs))
+        return unless local_name(element.name) == "style"
+
+        context.state_for(self).style_elements << element
+      end
+
+      def validate_sax_complete(context)
+        context.state_for(self).style_elements.each do |element|
+          report_all(element, context, css_findings(element.text_content.to_s))
+        end
+      end
+
+      def validate_source(source, context)
+        return if source.nil?
+
+        report_all(nil, context, source_findings(source.to_s))
+      end
+
+      # Reference findings for one element's attributes: [{attr:, value:, reason:}]
+      def attribute_findings(element_name, attrs, depth: 0, seen: [])
+        findings = []
+        attrs.each do |name, value|
+          local = local_name(name)
+          if local == "href"
+            findings.concat(reference_findings(value, element_name, local,
+                                               depth, seen))
+          elsif local == "style"
+            findings.concat(css_findings(value, depth: depth, seen: seen,
+                                                element_name: element_name))
+          elsif URL_ATTRIBUTES.include?(local)
+            findings.concat(css_findings(value, depth: depth, seen: seen,
+                                                element_name: element_name,
+                                                attribute_name: name,
+                                                urls_only: true))
+          end
+        end
+        findings
+      end
+
+      def css_findings(css, depth: 0, seen: [], element_name: "style",
+                       attribute_name: "style", urls_only: false)
+        Validation::CssReferences.extract(css).flat_map do |reference|
+          next [] if urls_only && reference.import
+
+          attr = reference.import ? "@import" : "url()"
+          reference_findings(reference.url.strip, element_name,
+                             "#{attribute_name} #{attr}", depth, seen)
+        end
+      end
+
+      def source_findings(source)
+        source.to_enum(:scan, STYLESHEET_PI).flat_map do
+          body = Regexp.last_match[:body]
+          href = body[/\bhref\s*=\s*(?:"([^"]*)"|'([^']*)')/, 1] ||
+            body[/\bhref\s*=\s*'([^']*)'/, 1]
+          next [] if href.nil? || href.empty?
+
+          reference_findings(href, "xml-stylesheet", "href", 0, [])
+        end
+      end
+
+      private
+
+      def reference_findings(value, element_name, attribute_name, depth, seen)
+        reference = References::ReferenceClassifier.classify(
+          value, element_name: element_name, attribute_name: attribute_name
+        )
+        return [] unless reference
+
+        reason = rejection_reason(reference, depth, seen)
+        return [] unless reason
+
+        [{ attr: attribute_name, value: value,
+           type: reference.class.name.split("::").last, reason: reason }]
+      end
+
+      def rejection_reason(reference, depth, seen)
+        case reference
+        when References::InternalFragmentReference then nil
+        when References::DataUriReference then data_uri_reason(reference, depth,
+                                                               seen)
+        when References::UrnReference then "URN requires an external resource"
+        when References::ExternalUrlReference
+          "network resource is not allowed"
+        else "reference requires another document or local file"
+        end
+      end
+
+      def data_uri_reason(reference, depth, seen)
+        type = reference.normalized_media_type
+        unless ALLOWED_DATA_TYPES.include?(type)
+          return "unsupported data URL media type '#{type}'"
+        end
+
+        return reference.decode_error if reference.decode_error
+
+        if type == "image/svg+xml"
+          svg_data_reason(reference.payload, depth, seen)
+        elsif (error = reference.raster_error)
+          "invalid #{type} payload: #{error}"
+        end
+      end
+
+      def svg_data_reason(payload, depth, seen)
+        if depth >= max_data_uri_depth
+          return "SVG data URL nesting exceeds #{max_data_uri_depth}"
+        end
+
+        digest = payload.hash
+        return "SVG data URL contains a reference cycle" if seen.include?(digest)
+
+        text = payload.dup.force_encoding(Encoding::UTF_8)
+        return "SVG data URL is not valid UTF-8" unless text.valid_encoding?
+        if text.match?(EXTERNAL_DOCTYPE)
+          return "SVG data URL declares external entities"
+        end
+
+        nested = nested_findings(text, depth + 1, seen + [digest])
+        return nested if nested.is_a?(String)
+
+        first = nested.first
+        first && "nested #{first[:attr]} '#{truncate(first[:value])}': #{first[:reason]}"
+      end
+
+      # Returns findings, or a String reason when the SVG is not usable
+      def nested_findings(text, depth, seen)
+        document = Document.from_content(text)
+        root = document.root
+        unless root && local_name(root.name) == SVG_NAMESPACE_ROOT
+          return "SVG data URL does not contain an svg document"
+        end
+
+        findings = source_findings(text)
+        document.traverse do |node|
+          next unless element?(node)
+
+          attrs = (node.attributes || []).to_h { |a| [a.name.to_s, a.value.to_s] }
+          findings.concat(attribute_findings(node.name, attrs, depth: depth,
+                                                               seen: seen))
+          if local_name(node.name) == "style"
+            findings.concat(css_findings(node.text.to_s, depth: depth,
+                                                         seen: seen))
+          end
+        end
+        findings
+      rescue StandardError
+        "SVG data URL is not well-formed XML"
+      end
+
+      def report_all(node, context, findings)
+        findings.each do |finding|
+          context.add_error(
+            requirement_id: id,
+            message: "External reference not allowed in #{finding[:attr]}: " \
+                     "'#{truncate(finding[:value])}' (#{finding[:reason]})",
+            node: node,
+            severity: :error,
+            data: { citation: citation_uri, attribute: finding[:attr],
+                    reference_type: finding[:type],
+                    reason: finding[:reason] },
+          )
+        end
+      end
+
+      def truncate(value)
+        value.length > 60 ? "#{value[0, 57]}..." : value
+      end
+
+      def local_name(name)
+        name.to_s.split(":").last
+      end
+    end
+  end
+end

data/lib/svg_conform/requirements/link_validation_requirement.rb

@@ -30,6 +30,7 @@ module SvgConform
           context.add_external_reference_notice(
             node: node,
             reference: reference,
+            requirement_id: id,
           )
         end
 
@@ -72,6 +73,7 @@ module SvgConform
               context.add_external_reference_notice(
                 node: element,
                 reference: reference,
+                requirement_id: id,
               )
             end
           end

data/lib/svg_conform/requirements/processing_features_requirement.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+require_relative "base_requirement"
+require_relative "../validation/css_references"
+
+module SvgConform
+  module Requirements
+    # Rejects processing features that a static profile does not allow.
+    #
+    # Each configured category (for example script, animation, interaction)
+    # carries its own requirement ID and normative citation, so a profile can
+    # report them as separate rules. DOM and SAX validation share #check_names.
+    class ProcessingFeaturesRequirement < BaseRequirement
+      # One rejected feature group
+      class Category < Lutaml::Model::Serializable
+        attribute :name, :string
+        attribute :id, :string
+        attribute :citation, :string
+        attribute :description, :string
+        attribute :elements, :string, collection: true, default: -> { [] }
+        attribute :attributes, :string, collection: true, default: -> { [] }
+        attribute :attribute_patterns, :string, collection: true,
+                                                default: -> { [] }
+
+        yaml do
+          map "name", to: :name
+          map "id", to: :id
+          map "citation", to: :citation
+          map "description", to: :description
+          map "elements", to: :elements
+          map "attributes", to: :attributes
+          map "attribute_patterns", to: :attribute_patterns
+        end
+
+        def rejects_element?(local_name)
+          elements.include?(local_name)
+        end
+
+        def rejects_attribute?(local_name)
+          attributes.include?(local_name) || matches_pattern?(local_name)
+        end
+
+        # CSS property names are checked against the attribute patterns only:
+        # the listed attribute names (cursor, begin, ...) are SVG attributes,
+        # not CSS declarations. Vendor prefixes (-webkit-) are ignored.
+        def rejects_css_property?(property)
+          matches_pattern?(property.downcase.sub(/\A-[a-z]+-/, ""))
+        end
+
+        # @keyframes only exists to drive CSS animation.
+        def rejects_keyframes?
+          rejects_css_property?("animation-name")
+        end
+
+        private
+
+        def matches_pattern?(name)
+          attribute_patterns.any? { |pattern| Regexp.new(pattern).match?(name) }
+        end
+      end
+
+      attribute :type, :string,
+                default: -> { "ProcessingFeaturesRequirement" }
+      attribute :categories, Category, collection: true, default: -> { [] }
+
+      yaml do
+        map "id", to: :id
+        map "description", to: :description
+        map "type", to: :type
+        map "categories", to: :categories
+      end
+
+      def needs_deferred_validation?
+        true
+      end
+
+      def check(node, context)
+        return unless element?(node)
+
+        attrs = (node.attributes || []).to_h { |attr| [attr.name.to_s, attr.value.to_s] }
+        check_names(node, local_name(node.name), attrs.keys, context)
+        check_css(node, attrs["style"], context)
+        check_css(node, node.text.to_s, context) if style_element?(node.name)
+      end
+
+      def collect_sax_data(element, context)
+        names = element.attributes.map { |attr| attr.name.to_s }
+        check_names(element, local_name(element.name), names, context)
+        check_css(element, element.raw_attributes["style"]&.to_s, context)
+        context.state_for(self).style_elements << element if style_element?(element.name)
+      end
+
+      def validate_sax_complete(context)
+        context.state_for(self).style_elements.each do |element|
+          check_css(element, element.text_content.to_s, context)
+        end
+      end
+
+      # Style elements seen while streaming; their text is only complete at the end
+      class State
+        attr_reader :style_elements
+
+        def initialize
+          @style_elements = []
+        end
+      end
+
+      private
+
+      def style_element?(name)
+        local_name(name) == "style"
+      end
+
+      # Declarations in a style attribute or style element content. Tokenized,
+      # so escaped property names (\61nimation) are decoded and text inside
+      # strings or comments is ignored.
+      def check_css(node, css, context)
+        return if css.nil? || css.empty?
+
+        Validation::CssReferences.declarations(css).each do |feature|
+          categories.each do |category|
+            next unless css_rejected?(category, feature)
+
+            report(context, node, category,
+                   "#{category.name} feature: #{feature.description} " \
+                   "is not allowed in static processing")
+          end
+        end
+      end
+
+      def css_rejected?(category, feature)
+        if feature.keyframes
+          category.rejects_keyframes?
+        else
+          category.rejects_css_property?(feature.name)
+        end
+      end
+
+      def check_names(node, element_name, attribute_names, context)
+        reported = []
+        categories.each do |category|
+          if category.rejects_element?(element_name)
+            report(context, node, category,
+                   "#{category.name} feature: element '#{element_name}' " \
+                   "is not allowed in static processing")
+          end
+
+          attribute_names.each do |attr_name|
+            next if reported.include?(attr_name)
+            next unless category.rejects_attribute?(attr_name)
+
+            reported << attr_name
+            report(context, node, category,
+                   "#{category.name} feature: attribute '#{attr_name}' " \
+                   "is not allowed in static processing")
+          end
+        end
+      end
+
+      def report(context, node, category, message)
+        context.add_error(
+          requirement_id: category.id || id,
+          message: message,
+          node: node,
+          severity: :error,
+          data: { category: category.name, citation: category.citation },
+        )
+      end
+
+      def local_name(name)
+        name.to_s.split(":").last
+      end
+    end
+  end
+end

data/lib/svg_conform/requirements/svg_1_1_document_requirement.rb

@@ -0,0 +1,213 @@
+# frozen_string_literal: true
+
+require "nokogiri"
+require "strscan"
+require_relative "base_requirement"
+require_relative "../validation/svg_1_1_document_conformance"
+require_relative "../validation/css2_core_grammar"
+
+module SvgConform
+  module Requirements
+    # Source-level document checks for SVG 1.1 Full. One profile entry runs
+    # one +rule+ (xml, root, version, grammar, css2 or xml_stylesheet), so each
+    # carries its own ID and citation. All rules work from the original
+    # source text through #validate_source, which both DOM and SAX
+    # validation invoke exactly once; the element callbacks do nothing.
+    class Svg11DocumentRequirement < BaseRequirement
+      RULES = %w[xml root version grammar css2 xml_stylesheet].freeze
+      SVG_NS = Validation::Svg11DocumentConformance::SVG_NS
+      STYLESHEET_TARGET = "xml-stylesheet"
+      CSS_MEDIA_TYPE = "text/css" # media types are case-insensitive
+      PSEUDO_ATTRIBUTES = %w[href type title media charset alternate].freeze
+      PSEUDO_ATTRIBUTE_PAIR = /\G\s*([^\s=]+)\s*=\s*(?:"([^"]*)"|'([^']*)')/
+      GRAMMAR_SKIPPED = %i[malformed_xml no_svg_root].freeze
+
+      # Per-validation cache shared by every rule entry of a profile
+      class State
+        attr_accessor :parsed, :conformance
+
+        def initialize
+          @parsed = nil
+          @conformance = nil
+        end
+      end
+
+      attribute :type, :string, default: -> { "Svg11DocumentRequirement" }
+      attribute :rule, :string
+
+      yaml do
+        map "id", to: :id
+        map "description", to: :description
+        map "citation_uri", to: :citation_uri
+        map "citation_label", to: :citation_label
+        map "type", to: :type
+        map "rule", to: :rule
+      end
+
+      def validate_source(source, context)
+        return if source.nil?
+        unless RULES.include?(rule)
+          raise ArgumentError,
+                "Svg11DocumentRequirement #{id}: unknown rule #{rule.inspect}"
+        end
+
+        send(:"check_#{rule}", source.to_s, context)
+      end
+
+      def validate_document(_document, _context); end
+
+      def check(_node, _context); end
+
+      private
+
+      def check_xml(source, context)
+        if context.source_serialized?
+          return fail_with(context, "source was re-serialized from a parsed " \
+                                    "tree; its XML declaration, doctype and " \
+                                    "processing instructions cannot be proved")
+        end
+
+        parsed = parse(source, context)
+        return unless parsed.is_a?(Hash) && parsed[:error]
+
+        fail_with(context, "document is not well-formed XML: #{parsed[:error].message}",
+                  line: parsed[:error].line)
+      end
+
+      def check_root(source, context)
+        root = root_of(source, context)
+        return unless root
+        return if root.name == "svg" && root.namespace&.href == SVG_NS
+
+        fail_with(context, "document element must be 'svg' in the " \
+                           "#{SVG_NS} namespace, found " \
+                           "'#{root.name}' in '#{root.namespace&.href}'")
+      end
+
+      def check_version(source, context)
+        root = root_of(source, context)
+        return unless root
+
+        value = root["version"]
+        return if value == "1.1"
+
+        fail_with(context, value ? "root version must be \"1.1\", found #{value.inspect}" : "root element does not declare version=\"1.1\"")
+      end
+
+      def check_grammar(source, context)
+        result = conformance(source, context)
+        result.issues.each do |issue|
+          next if GRAMMAR_SKIPPED.include?(issue.kind)
+
+          fail_with(context, "SVG 1.1 DTD (#{issue.kind}): #{issue.message}",
+                    line: issue.line)
+        end
+      end
+
+      def check_css2(source, context)
+        parsed = parse(source, context)
+        return unless parsed.is_a?(Nokogiri::XML::Document)
+
+        parsed.traverse do |node|
+          next unless node.element? && node.namespace&.href == SVG_NS
+
+          check_style_attribute(node, context)
+          check_style_element(node, context)
+        end
+      end
+
+      def check_xml_stylesheet(source, context)
+        parsed = parse(source, context)
+        return unless parsed.is_a?(Nokogiri::XML::Document)
+
+        parsed.children.each do |node|
+          next unless node.processing_instruction? && node.name == STYLESHEET_TARGET
+
+          stylesheet_problems(node.content).each do |problem|
+            fail_with(context, "xml-stylesheet: #{problem}", line: node.line)
+          end
+        end
+      end
+
+      def check_style_attribute(node, context)
+        value = node["style"]
+        return unless value
+
+        report_css(Validation::Css2CoreGrammar.parse_declarations(value),
+                   "style attribute on '#{node.name}'", node, context)
+      end
+
+      def check_style_element(node, context)
+        return unless node.name == "style"
+        return unless ["", CSS_MEDIA_TYPE].include?(node["type"].to_s.downcase)
+
+        report_css(Validation::Css2CoreGrammar.parse_stylesheet(node.content),
+                   "style element", node, context)
+      end
+
+      def report_css(result, where, node, context)
+        result.errors.each do |error|
+          fail_with(context, "CSS 2 grammar in #{where}: #{error}",
+                    line: node.line)
+        end
+      end
+
+      # Pseudo-attribute syntax of the xml-stylesheet Recommendation plus the
+      # SVG applicability rule that a declared type must be CSS.
+      def stylesheet_problems(content)
+        problems = []
+        pairs = []
+        scanner = StringScanner.new(content)
+        until scanner.eos?
+          unless scanner.scan(PSEUDO_ATTRIBUTE_PAIR)
+            problems << "malformed pseudo-attribute near #{scanner.rest.strip[0, 20].inspect}"
+            break
+          end
+          pairs << [scanner[1], scanner[2] || scanner[3]]
+        end
+        names = pairs.map(&:first)
+        problems << "duplicate pseudo-attribute #{names.tally.select { |_, n| n > 1 }.keys.first}" if names.uniq.size != names.size
+        names.reject { |n| PSEUDO_ATTRIBUTES.include?(n) }.each do |name|
+          problems << "unknown pseudo-attribute '#{name}'"
+        end
+        values = pairs.to_h
+        problems << "href pseudo-attribute is required" if problems.empty? && values["href"].to_s.empty?
+        if values["type"] && values["type"].downcase != CSS_MEDIA_TYPE
+          problems << "type #{values['type'].inspect} is not applicable to SVG (text/css expected)"
+        end
+        if values["alternate"] && !%w[yes no].include?(values["alternate"])
+          problems << "alternate must be \"yes\" or \"no\""
+        end
+        problems
+      end
+
+      def conformance(source, context)
+        state = context.state_for(self)
+        state.conformance ||= Validation::Svg11DocumentConformance.new.validate(source)
+      end
+
+      # Non-validating, offline parse; a Hash with :error when malformed.
+      def parse(source, context)
+        state = context.state_for(self)
+        state.parsed ||= begin
+          doc = Nokogiri::XML::Document.parse(source) { |c| c.strict.nonet }
+          doc.root ? doc : { error: Nokogiri::XML::SyntaxError.new("document has no root element") }
+        rescue Nokogiri::XML::SyntaxError => e
+          { error: e }
+        end
+      end
+
+      def root_of(source, context)
+        parsed = parse(source, context)
+        parsed.is_a?(Nokogiri::XML::Document) ? parsed.root : nil
+      end
+
+      def fail_with(context, message, line: nil)
+        data = { citation: citation_uri }
+        data[:line] = line if line.is_a?(Integer) && line.positive?
+        context.add_error(requirement_id: id, message: message, node: nil,
+                          severity: :error, data: data)
+      end
+    end
+  end
+end

data/lib/svg_conform/requirements.rb

@@ -19,6 +19,9 @@ require_relative "requirements/no_external_css_requirement"
 require_relative "requirements/no_external_fonts_requirement"
 require_relative "requirements/no_external_images_requirement"
 require_relative "requirements/text_as_path_requirement"
+require_relative "requirements/processing_features_requirement"
+require_relative "requirements/svg_1_1_document_requirement"
+require_relative "requirements/external_references_requirement"
 
 module SvgConform
   module Requirements
@@ -40,6 +43,9 @@ module SvgConform
         LinkValidationRequirement,
         IdReferenceRequirement,
         TextAsPathRequirement,
+        ProcessingFeaturesRequirement,
+        Svg11DocumentRequirement,
+        ExternalReferencesRequirement,
       ]
     end
 

data/lib/svg_conform/sax_document.rb

@@ -14,18 +14,22 @@ module SvgConform
       new(File.read(file_path), file_path)
     end
 
-    def self.from_content(content)
-      new(content, nil)
+    def self.from_content(content, source_serialized: false)
+      new(content, nil, source_serialized: source_serialized)
     end
 
-    def initialize(content, file_path = nil)
+    def initialize(content, file_path = nil, source_serialized: false)
       @content = content
       @file_path = file_path
+      @source_serialized = source_serialized
     end
 
     # Validate using SAX streaming parser
     def validate_with_profile(profile)
-      handler = SaxValidationHandler.new(profile)
+      handler = SaxValidationHandler.new(
+        profile, source: @content, source_path: @file_path,
+                 source_serialized: @source_serialized
+      )
       parser = Leptris::XML::SAX::Parser.new(handler)
 
       begin