svg_conform 0.2.4 → 0.2.7

data/lib/svg_conform/diagnostics/lens_core_adapter.rb

@@ -0,0 +1,200 @@
+# frozen_string_literal: true
+
+begin
+  require "lens_core"
+rescue LoadError
+  nil
+end
+
+module SvgConform
+  module Diagnostics
+    # Raised when an issue's data holds a value that cannot be written as
+    # JSON (for example an arbitrary Ruby object).
+    class UnsupportedContextError < SvgConform::Error; end
+
+    # Maps a ValidationResult onto one LensCore::Report.
+    #
+    #   errors          -> error,   kind: violation type, else "validation"
+    #   validity_errors -> error,   kind: "validity"
+    #   warnings        -> warning, kind: violation type, else "validation"
+    #   infos           -> info,    kind: violation type, else "notice"
+    #
+    # Order within each channel follows the source collections; channels are
+    # emitted in the order above.
+    module LensCoreAdapter
+      PRODUCER = "svg_conform"
+      REMEDIATION_FIELDS = %i[fixable remediable remediation_type
+                              remediation_confidence affects_content].freeze
+
+      module_function
+
+      # @param validation_result [SvgConform::ValidationResult]
+      # @param filename [String, nil] overrides the document's file path
+      # @param timestamp [Time, String, nil] caller supplied, never defaulted
+      # @return [LensCore::Report]
+      # @raise [UnsupportedContextError] for non-JSON issue data
+      def call(validation_result, filename: nil, timestamp: nil)
+        profile = validation_result.profile
+        LensCore::Report.new(
+          producer: LensCore::Producer.new(name: PRODUCER,
+                                           version: SvgConform::VERSION),
+          profile: LensCore::Profile.new(
+            id: profile.name.to_s,
+            citations: citations(profile.specification_uri,
+                                 profile.specification_label),
+          ),
+          valid: validation_result.valid?,
+          diagnostics: diagnostics(validation_result, profile),
+          timestamp: timestamp,
+          extensions: file_extension(validation_result, filename),
+        )
+      end
+
+      def file_extension(result, filename)
+        file = filename || result.document&.file_path
+        file ? { "file" => file.to_s } : {}
+      end
+
+      def diagnostics(result, profile)
+        [
+          *convert(result.errors, "error", "validation", profile),
+          *convert(result.validity_errors, "error", "validity", profile,
+                   force_kind: true),
+          *convert(result.warnings, "warning", "validation", profile),
+          *convert(result.infos, "info", "notice", profile, remediation: false),
+        ]
+      end
+
+      def convert(issues, severity, fallback_kind, profile, force_kind: false,
+                  remediation: true)
+        issues.map do |issue|
+          kind = force_kind ? fallback_kind : kind_for(issue, fallback_kind)
+          build(issue, severity, kind, profile, remediation)
+        end
+      end
+
+      def build(issue, severity, kind, profile, remediation)
+        requirement_id = issue.requirement_id
+        LensCore::Diagnostic.new(
+          severity: severity, kind: kind, requirement_id: requirement_id,
+          message: issue.message.to_s,
+          citations: issue_citations(issue, profile, requirement_id),
+          remediation: (issue.suggested_action if remediation && issue.remediable?),
+          context: context(issue, remediation),
+          location: location(issue)
+        )
+      end
+
+      def kind_for(issue, fallback)
+        type = issue.violation_type
+        return fallback if type.nil? || type.to_s.empty? ||
+          type.to_s == "unknown_violation"
+
+        type.to_s
+      end
+
+      # A requirement's own citation, else the one an issue carries in its
+      # data (a requirement reporting several IDs, such as the processing
+      # categories, cites per issue).
+      def issue_citations(issue, profile, requirement_id)
+        found = requirement_citations(profile, requirement_id)
+        return found unless found.empty?
+
+        data = issue.data
+        uri = data.is_a?(Hash) ? (data[:citation] || data["citation"]) : nil
+        citations(uri, nil)
+      end
+
+      def requirement_citations(profile, requirement_id)
+        requirement = profile.get_requirement(requirement_id)
+        return [] unless requirement
+
+        citations(requirement.citation_uri, requirement.citation_label)
+      end
+
+      def citations(uri, label)
+        return [] if uri.nil? || uri.to_s.empty?
+
+        [LensCore::Citation.new(uri: uri.to_s, label: label&.to_s)]
+      end
+
+      def context(issue, remediation)
+        context = {}
+        element = issue.element_name
+        context["element"] = element.to_s if element
+        if remediation
+          REMEDIATION_FIELDS.each do |field|
+            context[field.to_s] = json_value(remediation_value(issue, field),
+                                             field.to_s)
+          end
+        end
+        data = issue.data
+        unless data.nil? || (data.respond_to?(:empty?) && data.empty?)
+          context["data"] = json_value(data, "data")
+        end
+        context
+      end
+
+      def remediation_value(issue, field)
+        case field
+        when :fixable then issue.fixable?
+        when :remediable then issue.remediable?
+        when :affects_content then issue.affects_content?
+        else issue.public_send(field)
+        end
+      end
+
+      def location(issue)
+        node = issue.node
+        line = issue.line || data_coordinate(issue, :line)
+        column = issue.column || data_coordinate(issue, :column)
+        path = node.respond_to?(:path_id) ? node.path_id : nil
+        line = nil unless line.is_a?(Integer) && line >= 1
+        column = nil unless column.is_a?(Integer) && column >= 1
+        return nil if line.nil? && column.nil? && path.nil?
+
+        LensCore::Location.xml(line: line, column: column, path: path)
+      end
+
+      # Source-level requirements have no node and keep their position in data
+      def data_coordinate(issue, key)
+        data = issue.data
+        data.is_a?(Hash) ? data[key] : nil
+      end
+
+      # Deep copy into JSON primitives. Symbols become strings; anything else
+      # that JSON cannot carry fails with a stable error naming the path.
+      def json_value(value, path)
+        case value
+        when nil, true, false, Integer, String then value
+        when Float then json_float(value, path)
+        when Symbol then value.to_s
+        when Array
+          value.each_with_index.map { |v, i| json_value(v, "#{path}[#{i}]") }
+        when Hash then json_hash(value, path)
+        else
+          raise UnsupportedContextError,
+                "unsupported value of type #{value.class} at #{path}; " \
+                "issue data must be JSON-safe"
+        end
+      end
+
+      def json_float(value, path)
+        return value if value.finite?
+
+        raise UnsupportedContextError,
+              "unsupported non-finite number at #{path}"
+      end
+
+      def json_hash(hash, path)
+        hash.to_h do |key, v|
+          unless key.is_a?(String) || key.is_a?(Symbol)
+            raise UnsupportedContextError,
+                  "unsupported key of type #{key.class} at #{path}"
+          end
+          [key.to_s, json_value(v, "#{path}.#{key}")]
+        end
+      end
+    end
+  end
+end

data/lib/svg_conform/document.rb

@@ -8,6 +8,16 @@ module SvgConform
   class Document
     attr_reader :file_path, :moxml_document
 
+    # Original input text; a serialization when built via from_node
+    def source
+      @content
+    end
+
+    # True when #source was serialized from a node, not the original input
+    def source_serialized?
+      @source_serialized ? true : false
+    end
+
     def initialize(content_or_path)
       if File.exist?(content_or_path.to_s)
         @file_path = content_or_path
@@ -33,13 +43,14 @@ module SvgConform
     # Avoids re-parsing when input is already a DOM object
     def self.from_node(node)
       doc = allocate
+      doc.instance_variable_set(:@source_serialized, true)
       doc.instance_variable_set(:@file_path, nil)
       doc.instance_variable_set(:@xpath_cache, {})
 
       # Convert node to Moxml document
       if node.respond_to?(:to_xml) && node.class.name.start_with?("Moxml")
         # Already a Moxml node, wrap it
-        doc.instance_variable_set(:@content, nil) # Don't store XML string
+        doc.instance_variable_set(:@content, node.to_xml)
         doc.instance_variable_set(:@moxml_document,
                                   node.is_a?(Moxml::Document) ? node : wrap_moxml_element(node))
       elsif defined?(Leptris) && node.is_a?(Leptris::XML::Node)

data/lib/svg_conform/external_checkers/svgcheck/parser.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "yaml"
-
 module SvgConform
   module ExternalCheckers
     module Svgcheck
@@ -26,7 +24,7 @@ module SvgConform
 
         def load_mapping_config
           @mapping_config = if File.exist?(@mapping_config_path)
-                              YAML.load_file(@mapping_config_path)
+                              SvgConform::YamlIO.load_file(@mapping_config_path)
                             else
                               # Fallback to empty config if file doesn't exist
                               {

data/lib/svg_conform/node_helpers.rb

@@ -66,7 +66,7 @@ module SvgConform
         # the wrapper's #remove works on every adapter.
         local_name = name.include?(":") ? name.split(":", 2).last : name
         attr = Array(node.attributes).find do |a|
-          a.respond_to?(:name) && (a.name == name || a.name == local_name) &&
+          a.respond_to?(:name) && [name, local_name].include?(a.name) &&
             a.respond_to?(:remove)
         end
         return false unless attr

data/lib/svg_conform/profile.rb

@@ -15,6 +15,8 @@ module SvgConform
     attribute :name, :string
     attribute :description, :string
     attribute :import, :string
+    attribute :specification_uri, :string
+    attribute :specification_label, :string
     attribute :requirements, SvgConform::Requirements::BaseRequirement,
               collection: true, polymorphic: true
     attribute :remediations, SvgConform::Remediations::BaseRemediation,
@@ -48,6 +50,8 @@ module SvgConform
       map "name", to: :name
       map "description", to: :description
       map "import", to: :import
+      map "specification_uri", to: :specification_uri
+      map "specification_label", to: :specification_label
       map "requirements", to: :requirements, polymorphic: {
         attribute: "type",
         class_map: REQUIREMENTS_CLASS_MAP,
@@ -122,10 +126,15 @@ module SvgConform
       # If it's a Document object, it's already loaded into DOM
       # Use DOM validation (safe, already in memory)
       if document.is_a?(Document)
-        context = ValidationContext.new(document, self)
+        context = ValidationContext.new(
+          document, self,
+          source: document.source, source_path: document.file_path,
+          source_serialized: document.source_serialized?
+        )
 
         # Validate using requirements system
         requirements&.each do |requirement|
+          requirement.validate_source(document.source, context)
           requirement.validate_document(document, context)
         end
 
@@ -134,7 +143,7 @@ module SvgConform
         # For other document objects, serialize and use SAX for safety
         # (This handles leptris/Moxml documents that aren't wrapped in Document)
         content = document.to_xml
-        sax_doc = SaxDocument.from_content(content)
+        sax_doc = SaxDocument.from_content(content, source_serialized: true)
         sax_doc.validate_with_profile(self)
       else
         # Fallback to DOM mode for non-serializable objects

data/lib/svg_conform/quality_metrics/complexity_calculator.rb

@@ -63,12 +63,12 @@ module SvgConform
         # Track opening and closing tags to estimate nesting
         depth = 0
         max_depth = 0
-        in_tag = false
+        false
 
         content.each_char do |char|
           case char
           when "<"
-            in_tag = true
+            true
             # Check if it's a closing tag
             if content[content.index(char) + 1] == "/"
               depth -= 1
@@ -77,7 +77,7 @@ module SvgConform
               max_depth = [max_depth, depth].max
             end
           when ">"
-            in_tag = false
+            false
           end
         end
 

data/lib/svg_conform/quality_metrics/configuration.rb

@@ -39,8 +39,10 @@ module SvgConform
             raise ArgumentError, "Configuration file not found: #{path}"
           end
 
-          hash = YAML.safe_load_file(path, permitted_classes: [Symbol],
-                                           permitted_symbols: [], aliases: true)
+          hash = SvgConform::YamlIO.safe_load_file(
+            path, permitted_classes: [Symbol], permitted_symbols: [],
+                  aliases: true
+          )
           new(hash)
         end
 

data/lib/svg_conform/references/base_reference.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "lutaml/model"
+require "zlib"
 
 module SvgConform
   module References
@@ -116,6 +117,9 @@ module SvgConform
 
     # Data URI reference (data:*)
     class DataUriReference < BaseReference
+      PARSE = /\Adata:(?<head>[^,]*),(?<body>.*)\z/mi
+      PNG_SIGNATURE = "\x89PNG\r\n\x1A\n".b.freeze
+
       def validation_scope
         :internal
       end
@@ -125,6 +129,155 @@ module SvgConform
         match = value.match(%r{^data:([^;,]+)})
         match ? match[1] : nil
       end
+
+      # Lowercased media type, defaulting per RFC 2397 when omitted
+      def normalized_media_type
+        (media_type || "text/plain").strip.downcase
+      end
+
+      def base64?
+        match = PARSE.match(value)
+        return false unless match
+
+        match[:head].split(";").map { |part| part.strip.downcase }
+          .include?("base64")
+      end
+
+      # Raw payload bytes (binary string), or nil when #decode_error is set
+      def payload
+        decode unless defined?(@payload)
+        @payload
+      end
+
+      # Why the payload cannot be decoded, or nil
+      def decode_error
+        decode unless defined?(@payload)
+        @decode_error
+      end
+
+      # Why the decoded raster payload is not a PNG/JPEG file, or nil.
+      # Only meaningful for image/png and image/jpeg media types.
+      def raster_error
+        return decode_error if decode_error
+        return "empty payload" if payload.empty?
+
+        case normalized_media_type
+        when "image/png" then png_error(payload)
+        when "image/jpeg" then jpeg_error(payload)
+        end
+      end
+
+      private
+
+      def decode
+        @payload = nil
+        @decode_error = nil
+        match = PARSE.match(value)
+        unless match
+          @decode_error = "missing ',' separator"
+          return
+        end
+
+        body = match[:body]
+        if base64?
+          decode_base64(body)
+        else
+          decode_percent(body)
+        end
+      end
+
+      def decode_base64(body)
+        require "base64"
+        @payload = Base64.strict_decode64(percent_unescape(body).delete("\s"))
+      rescue ArgumentError
+        @decode_error = "malformed base64 payload"
+      end
+
+      def decode_percent(body)
+        @payload = percent_unescape(body)
+      rescue ArgumentError
+        @decode_error = "malformed percent-encoding"
+      end
+
+      def percent_unescape(text)
+        raise ArgumentError, "bad escape" if text.match?(/%(?!\h\h)/)
+
+        text.b.gsub(/%(\h\h)/) { Regexp.last_match(1).hex.chr }
+      end
+
+      def png_error(bytes)
+        return "not a PNG file" unless bytes.start_with?(PNG_SIGNATURE)
+
+        offset = PNG_SIGNATURE.bytesize
+        first = true
+        while offset + 12 <= bytes.bytesize
+          length = bytes.byteslice(offset, 4).unpack1("N")
+          type = bytes.byteslice(offset + 4, 4)
+          return "PNG must start with IHDR" if first && type != "IHDR"
+          return "truncated PNG chunk" if offset + 12 + length > bytes.bytesize
+
+          data = bytes.byteslice(offset + 4, 4 + length)
+          crc = bytes.byteslice(offset + 8 + length, 4).unpack1("N")
+          return "PNG chunk checksum mismatch" unless Zlib.crc32(data) == crc
+          return nil if type == "IEND"
+
+          first = false
+          offset += 12 + length
+        end
+        "PNG is missing IEND"
+      end
+
+      # Walks the marker segments: every segment with a length must fit in the
+      # payload, entropy-coded scan data is skipped to the next marker, and the
+      # file must end with EOI. This proves the structure, not that pixels decode.
+      def jpeg_error(bytes)
+        return "not a JPEG file" unless bytes.start_with?("\xFF\xD8\xFF".b)
+
+        offset = 2
+        while offset < bytes.bytesize
+          return "malformed JPEG marker" unless bytes.getbyte(offset) == 0xFF
+
+          offset += 1 while bytes.getbyte(offset + 1) == 0xFF
+          marker = bytes.getbyte(offset + 1)
+          return "truncated JPEG" if marker.nil?
+          return jpeg_trailer_error(bytes, offset + 2) if marker == 0xD9
+
+          offset = jpeg_next_offset(bytes, offset + 2, marker)
+          return offset if offset.is_a?(String)
+        end
+        "truncated JPEG"
+      end
+
+      def jpeg_trailer_error(bytes, offset)
+        offset == bytes.bytesize ? nil : "data after JPEG end marker"
+      end
+
+      # Offset of the marker after the segment (and scan data) at +offset+,
+      # or an error String
+      def jpeg_next_offset(bytes, offset, marker)
+        return offset if marker == 0x01 || marker.between?(0xD0, 0xD8)
+
+        length = bytes.byteslice(offset, 2)&.unpack1("n")
+        return "truncated JPEG segment" if length.nil?
+        return "invalid JPEG segment length" if length < 2
+        return "truncated JPEG segment" if offset + length > bytes.bytesize
+
+        offset += length
+        marker == 0xDA ? jpeg_skip_scan(bytes, offset) : offset
+      end
+
+      def jpeg_skip_scan(bytes, offset)
+        while offset < bytes.bytesize
+          if bytes.getbyte(offset) == 0xFF
+            following = bytes.getbyte(offset + 1)
+            return offset unless following.nil? || following.zero? || following.between?(0xD0, 0xD7)
+
+            offset += 1 if following
+          end
+          offset += 1
+        end
+        "truncated JPEG"
+      end
     end
   end
 end

data/lib/svg_conform/references/reference_manifest.rb

@@ -115,8 +115,7 @@ column_number: nil)
 
       # Export as YAML for easy inspection
       def to_yaml
-        require "yaml"
-        to_h.to_yaml
+        SvgConform::YamlIO.dump(to_h)
       end
 
       # Export as JSON for programmatic processing

data/lib/svg_conform/report_comparator.rb

@@ -752,10 +752,10 @@ filename)
       render_gh_style_table(headers, rows)
 
       puts "\n#{Paint['📊 COMPATIBILITY METRICS:', :blue, :bold]}"
-      puts "  🗂️  Total files processed: #{Paint[total_files.to_s, :cyan,
-                                                :bold]}"
-      puts "  ✅ Files with matching error counts: #{Paint[matching_files.to_s,
-                                                           :green, :bold]}"
+      total_label = Paint[total_files.to_s, :cyan, :bold]
+      matching_label = Paint[matching_files.to_s, :green, :bold]
+      puts "  🗂️  Total files processed: #{total_label}"
+      puts "  ✅ Files with matching error counts: #{matching_label}"
 
       # Color-code the percentage based on value
       percentage_color = if match_percentage >= 90

data/lib/svg_conform/requirements/base_requirement.rb

@@ -95,6 +95,8 @@ module SvgConform
 
       attribute :id, :string
       attribute :description, :string
+      attribute :citation_uri, :string
+      attribute :citation_label, :string
       attribute :type, :string, polymorphic_class: true, default: -> {
         self.class.name&.split("::")&.last
       }
@@ -102,6 +104,8 @@ module SvgConform
       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
       end
 
@@ -121,6 +125,8 @@ module SvgConform
 
       # Called for each element during SAX parsing
       # Override in subclasses for immediate validation
+      def validate_source(source, context); end
+
       def validate_sax_element(element, context)
         # Default: Empty - subclasses must override for SAX support
         # Cannot call check() here as it's abstract