canon 0.3.121 → 0.3.123

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ea0a5d94e934c12df80540761d13587ddf9adabad10db384f7bfad3b640affbf
-  data.tar.gz: 27ad206ee9f2fc7bb0c37b09948716ee46bb42fbaa2894b813feb90246823343
+  metadata.gz: e746e8d1590e8be637395d2c68cb17a8b5aa9c742cbdc2c08d2e9becb42164a4
+  data.tar.gz: 8b0cefd9a990836130415fa12491628d992746d9521f00d5768c0c39717fc09c
 SHA512:
-  metadata.gz: 961d3fda5a67a3219e7fad26f5d90cf52ad691e7e625d8f831d29d29cd81593147617cef7dbe17073ecf7d1ad279af0ea941f2d20a88652857e90f373bd6bdec
-  data.tar.gz: 99f8e9910736ee42355ccd4a7350d9ba56ed819eb1a2530ed326dd2cc2524b4ddcb50ad7a3e87972279d962637ab2b04d65f79afcfb8b99562ad4697a1e01325
+  metadata.gz: 718f08d011e9df8965873679f6e0332b6dd871682257f73dc20046fd1138db5a279719b605833fdc339b05785a0f950337c69d9067eb446a7b4b1b9e468f2bfb
+  data.tar.gz: 0a874b40f3f194cd0998f7d01f59710b613f7b044ab7a17357d0fdc8877e71b4ae7058abe3a5d6705450dadb5c3ca93fa20c4f3437ca8c1f7e51aaf36a920af5

data/lib/canon/comparison.rb

@@ -646,6 +646,13 @@ module Canon
           return array_diff(obj1, obj2, resolved)
         end
 
+        # Hashes (metadata dumps the equivalent-xml matcher compared
+        # generically): key-wise deep comparison through the normal
+        # pipeline.
+        if obj1.is_a?(Hash) && obj2.is_a?(Hash)
+          return hash_diff(obj1, obj2, resolved)
+        end
+
         # Detect formats (with explicit hint) and pre-parse HTML strings
         # through Nokogiri::HTML5 so html4 and html5 share HTML's
         # whitespace-sensitivity semantics (issue #118).  Pre-parsing
@@ -699,29 +706,69 @@ module Canon
       # @param format1 [Symbol]
       # @param format2 [Symbol]
       # @return [Symbol]
+      SCALAR_LEAVES = [String, Symbol, Numeric, NilClass,
+                       TrueClass, FalseClass].freeze
+
+      def scalar_leaf?(obj)
+        SCALAR_LEAVES.any? { |k| obj.is_a?(k) }
+      end
+
       def array_diff(arr1, arr2, opts = {})
         verbose = opts[:verbose]
         if arr1.size != arr2.size
           return verbose ? [:size_mismatch] : false
         end
 
-        # Elements are extracted values, not documents: strings compare
-        # literally (a matcher format hint must not turn "ref1" into an
-        # XML fragment, where every bare string parses equal), and the
-        # format hint is dropped for the recursion on other scalars.
+        # Elements are extracted values, not documents: scalar leaves
+        # compare literally (a matcher format hint must not turn "ref1"
+        # into an XML fragment, where every bare string parses equal,
+        # and the detector has no format for numbers at all); containers
+        # and nodes recurse through the normal pipeline without the
+        # format hint.
+        scalar_opts = opts.except(:verbose, :format)
+        diffs = []
+        arr1.zip(arr2).each_with_index do |(element_before, element_after), i|
+          eq = if scalar_leaf?(element_before) && scalar_leaf?(element_after)
+                 element_before == element_after
+               else
+                 equivalent?(element_before, element_after, scalar_opts)
+               end
+          next if eq == true
+
+          return false unless verbose
+
+          diffs << leaf_diff(i.to_s, element_before, element_after)
+        end
+        verbose ? diffs : diffs.empty?
+      end
+
+      # Verbose ruby-object entries use the diff-code shape the
+      # DiffFormatter's by-object renderers consume.
+      def leaf_diff(path, value_before, value_after)
+        { path: path, diff_code: UNEQUAL_PRIMITIVES,
+          value1: value_before, value2: value_after }
+      end
+
+      def hash_diff(hash1, hash2, opts = {})
+        verbose = opts[:verbose]
+        if hash1.keys.sort != hash2.keys.sort
+          return verbose ? [:key_mismatch] : false
+        end
+
         scalar_opts = opts.except(:verbose, :format)
         diffs = []
-        arr1.zip(arr2).each_with_index do |(a, b), i|
-          eq = if a.is_a?(String) && b.is_a?(String)
-                 a == b
+        hash1.each do |key, value_before|
+          value_after = hash2[key]
+          eq = if scalar_leaf?(value_before) && scalar_leaf?(value_after)
+                 value_before == value_after
                else
-                 equivalent?(a, b, scalar_opts)
+                 equivalent?(value_before, value_after, scalar_opts)
                end
           next if eq == true
 
           return false unless verbose
 
-          diffs << { index: i, difference: eq == false ? :different : eq }
+          diffs << leaf_diff(key.to_s, value_before, value_after)
         end
         verbose ? diffs : diffs.empty?
       end

data/lib/canon/pretty_printer/html.rb

@@ -36,14 +36,10 @@ module Canon
       end
 
       def format(html_string)
-        if @fixture_ready
-          # The fixture-ready display mode is the one Nokogiri lane
-          # left (libxml FORMAT|AS_XHTML save flags — moxml#390 filed
-          # for an engine XHTML mode); everything else is engine-
-          # served.
-          Canon::NokogiriLoader.require!("HTML fixture-ready display")
-          return format_fixture_ready(html_string)
-        end
+        # The fixture-ready display lane is engine-served end to end
+        # (moxml 0.6.2's XHTML serialization mode — moxml#390): no
+        # Nokogiri requirement remains in this mode.
+        return format_fixture_ready(html_string) if @fixture_ready
 
         if xhtml?(html_string)
           format_as_xhtml(html_string)
@@ -91,14 +87,8 @@ module Canon
         end
       end
 
-      # Fixture-ready serialisation: parse with Nokogiri::HTML5 (so we
-      # get permissive recovery on real-world Word / XHTML5 / HTML5
-      # input shapes), then write through libxml's XML writer with
-      # +FORMAT+ + +AS_XHTML+ + +NO_DECLARATION+.  +FORMAT+ inserts
-      # indentation; +AS_XHTML+ produces well-shaped output (void
-      # elements self-closed, non-void paired); +NO_DECLARATION+
-      # suppresses the +<?xml ...?>+ prefix.
-      # Engine parse + significance-aware strip + the engine's
+      # Fixture-ready serialisation, engine-served end to end:
+      # engine HTML parse + significance-aware strip + moxml 0.6.2's
       # XHTML serialization mode (moxml#390 delivered to_xhtml /
       # to_html(xhtml: true)): void elements self-closed, non-void
       # paired — the AS_XHTML contract, engine-served.

data/lib/canon/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Canon
-  VERSION = "0.3.121"
+  VERSION = "0.3.123"
 end

data/lib/canon/xml/xpath_engine.rb

@@ -14,9 +14,14 @@ module Canon
     # - Predicates: [1] (position), [@attr], [@attr='value']
     # - Wildcards: *
     # - Union: expr1 | expr2
+    # - Self and parent steps: ., ..
+    # - Attribute steps: @attr (selects the attribute node; per C14N
+    #   law it renders only when its owner element is in the node-set,
+    #   so @attr/.. is the productive form — XPath 1.0 section 2.2
+    #   names the owner element)
     #
     # Not supported (not needed for C14N subset):
-    # - Axes other than child and descendant-or-self
+    # - Axes other than child, parent, self, descendant-or-self
     # - Functions (last(), position(), etc.)
     # - Variables
     #
@@ -56,6 +61,10 @@ module Canon
         elsif xpath.start_with?("/")
           # Absolute path
           evaluate_absolute(xpath[1..])
+        elsif xpath.start_with?("./")
+          # Document-rooted self step: the subset context is the
+          # document, so ./rest resolves from the root like /rest
+          evaluate_absolute(xpath[2..])
         else
           # Relative path — treat as descendant
           evaluate_descendant(xpath)
@@ -68,35 +77,47 @@ module Canon
         steps = parse_steps(path)
         return [] if steps.empty?
 
-        # Start from root's children
-        current_nodes = @root.children
-        apply_steps(current_nodes, steps)
+        # Start from root's children; the first element step filters
+        # this entry set directly
+        apply_steps(@root.children, steps, descend_first: false)
       end
 
       def evaluate_descendant(path)
         steps = parse_steps(path)
         return [] if steps.empty?
 
+        # ./ is transparent on the relative law: the subset context is
+        # the document, so ./rest searches descendants like rest
+        steps.shift while steps.first&.dig(:type) == :self
+        return [] if steps.empty?
+
         # Collect all descendant element nodes
         all_elements = []
         collect_elements(@root, all_elements)
 
-        # For each element, try to match the full path starting there
-        result = []
-        all_elements.each do |element|
-          first_step = steps.first
-          next unless step_matches?(element, first_step)
+        first_step = steps.first
+        remaining = steps[1..]
 
-          if steps.length == 1
-            result << element
+        context =
+          case first_step[:type]
+          when :attribute
+            # //@attr — every matching attribute in the tree
+            all_elements.flat_map do |element|
+              attribute_matches(element, first_step)
+            end
+          when :parent
+            return [] # no meaningful parents above descendants
           else
-            remaining = steps[1..]
-            matched = apply_steps(element.children, remaining)
-            result.concat(matched)
+            all_elements.select do |element|
+              step_matches?(element, first_step)
+            end
           end
-        end
+        return context.uniq if remaining.empty?
 
-        result.uniq
+        # The remaining steps run from the matches: element steps
+        # descend (block semantics), axis steps apply to the nodes
+        # themselves
+        apply_steps(context, remaining, descend_first: true).uniq
       end
 
       def collect_elements(node, result)
@@ -108,20 +129,54 @@ module Canon
         end
       end
 
-      def apply_steps(nodes, steps)
-        return nodes if steps.empty?
+      # Linear context model: each step transforms the current node
+      # set. Element steps filter one level down from the context
+      # (block semantics — the first step filters the entry set
+      # itself); parent/self/attribute steps are context steps and
+      # operate on the nodes themselves.
+      def apply_steps(nodes, steps, descend_first:)
+        steps.reduce(nodes) do |current, step|
+          break [] if current.empty?
+
+          if element_step?(step)
+            level = descend_first ? descend(current) : current
+            current = level.select { |n| step_matches?(n, step) }.uniq
+          else
+            current = axis_apply(current, step)
+          end
+          descend_first = true
+          current
+        end
+      end
 
-        step = steps.first
-        remaining = steps[1..]
+      def element_step?(step)
+        step[:type] == :element
+      end
 
-        matched = nodes.select { |n| step_matches?(n, step) }
+      def descend(nodes)
+        nodes.flat_map do |n|
+          next [] if n.is_a?(Nodes::AttributeNode)
 
-        if remaining.empty?
-          matched
-        else
-          matched.flat_map do |node|
-            apply_steps(node.children, remaining)
-          end
+          n.children
+        end
+      end
+
+      # Context steps: navigate from the nodes themselves.
+      def axis_apply(nodes, step)
+        case step[:type]
+        when :parent
+          nodes.filter_map(&:parent).uniq
+        when :self
+          nodes
+        when :attribute
+          nodes.grep(Nodes::ElementNode)
+            .flat_map { |el| attribute_matches(el, step) }.uniq
+        end
+      end
+
+      def attribute_matches(element, step)
+        element.attribute_nodes.select do |a|
+          attr_name_matches?(a, step[:name])
         end
       end
 
@@ -132,6 +187,17 @@ module Canon
           predicates_match?(node, step[:predicates])
       end
 
+      def attr_name_matches?(attr, name)
+        return true if name == "*"
+
+        if name.include?(":")
+          prefix, local = name.split(":", 2)
+          attr.prefix == prefix && attr.name == local
+        else
+          attr.name == name
+        end
+      end
+
       def name_matches?(node, name)
         return true if name == "*"
 
@@ -179,7 +245,7 @@ module Canon
       # Parse a path string into an array of steps.
       #
       # @param path [String] XPath path (without leading /)
-      # @return [Array<Hash>] Array of { name:, predicates: }
+      # @return [Array<Hash>] Array of { type:, name:, predicates: }
       def parse_steps(path)
         steps = []
         scanner = StringScanner.new(path)
@@ -189,14 +255,27 @@ module Canon
           break if scanner.eos?
 
           # Skip /
-          scanner.scan(%r{/})
+          scanner.skip(%r{/})
+          scanner.skip(/\s+/)
+
+          if scanner.scan("..")
+            steps << { type: :parent, name: nil, predicates: [] }
+            next
+          elsif scanner.scan(".")
+            steps << { type: :self, name: nil, predicates: [] }
+            next
+          elsif scanner.scan(/@/)
+            name = scanner.scan(/[a-zA-Z_][\w.-]*/)
+            steps << { type: :attribute, name: name, predicates: [] }
+            next
+          end
 
           name = scan_name(scanner)
           break if name.nil?
 
           predicates = scan_predicates(scanner)
 
-          steps << { name: name, predicates: predicates }
+          steps << { type: :element, name: name, predicates: predicates }
         end
 
         steps

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: canon
 version: !ruby/object:Gem::Version
-  version: 0.3.121
+  version: 0.3.123
 platform: ruby
 authors:
 - Ribose Inc.
@@ -58,14 +58,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.6.0
+        version: 0.6.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.6.0
+        version: 0.6.2
 - !ruby/object:Gem::Dependency
   name: paint
   requirement: !ruby/object:Gem::Requirement