canon 0.2.9 → 0.2.11

data/lib/canon/diff_formatter/by_object/xml_formatter.rb

@@ -136,7 +136,16 @@ module Canon
                 theme_color(:changed, :marker) || :yellow,
               )}"
             end
-          when :structural_whitespace, :attribute_whitespace, :attribute_values
+          when :attribute_values
+            render_attribute_values_diffnode(diff_node, node1, node2, prefix,
+                                             output)
+          when :attribute_presence
+            render_attribute_presence_diffnode(diff_node, node1, node2, prefix,
+                                               output)
+          when :attribute_order
+            render_attribute_order_diffnode(diff_node, node1, node2, prefix,
+                                            output)
+          when :structural_whitespace, :attribute_whitespace
             output << "#{prefix}└── #{colorize(
               "[#{diff_node.dimension}: #{diff_node.reason}]",
               theme_color(:changed, :marker) || :yellow,
@@ -150,6 +159,115 @@ module Canon
           end
         end
 
+        # Render attribute value DiffNode with per-attribute before/after
+        def render_attribute_values_diffnode(diff_node, node1, node2, prefix,
+                                             output)
+          attrs1 = diff_node.attributes_before ||
+            extract_attributes_hash(node1)
+          attrs2 = diff_node.attributes_after ||
+            extract_attributes_hash(node2)
+          element_name = if node1
+                           node1.name
+                         else
+                           (node2 ? node2.name : "?")
+                         end
+
+          output << "#{prefix}└── #{colorize(
+            "Element: <#{element_name}>",
+            theme_color(:changed, :marker) || :yellow,
+          )}"
+
+          differing = find_differing_attributes(attrs1, attrs2)
+          differing.each_with_index do |name, i|
+            connector = i < differing.size - 1 ? "├──" : "└──"
+            val1 = attrs1[name].to_s
+            val2 = attrs2[name].to_s
+            output << "#{prefix}    #{connector} " \
+                      "#{colorize("#{name}:", :cyan)} " \
+                      "#{colorize(val1,
+                                  theme_color(:removed, :content) || :red)} " \
+                      "→ " \
+                      "#{colorize(val2,
+                                  theme_color(:added, :content) || :green)}"
+          end
+        end
+
+        # Render attribute presence DiffNode with added/removed attributes
+        def render_attribute_presence_diffnode(diff_node, node1, node2, prefix,
+                                               output)
+          attrs1 = diff_node.attributes_before ||
+            extract_attributes_hash(node1)
+          attrs2 = diff_node.attributes_after ||
+            extract_attributes_hash(node2)
+          element_name = if node1
+                           node1.name
+                         else
+                           (node2 ? node2.name : "?")
+                         end
+
+          output << "#{prefix}└── #{colorize(
+            "Element: <#{element_name}>",
+            theme_color(:changed, :marker) || :yellow,
+          )}"
+
+          keys1 = attrs1.keys.to_set
+          keys2 = attrs2.keys.to_set
+          removed = (keys1 - keys2).sort
+          added = (keys2 - keys1).sort
+          items = removed.map { |k| [:removed, k, attrs1[k]] }
+          added.each { |k| items << [:added, k, attrs2[k]] }
+
+          items.each_with_index do |(type, name, val), i|
+            connector = i < items.size - 1 ? "├──" : "└──"
+            color = if type == :removed
+                      theme_color(:removed,
+                                  :content) || :red
+                    else
+                      theme_color(
+                        :added, :content
+                      ) || :green
+                    end
+            sign = type == :removed ? "-" : "+"
+            output << "#{prefix}    #{connector} " \
+                      "#{colorize("#{sign} #{name}=\"#{val}\"", color)}"
+          end
+        end
+
+        # Render attribute order DiffNode with before/after order
+        def render_attribute_order_diffnode(diff_node, node1, node2, prefix,
+                                            output)
+          attrs1 = diff_node.attributes_before ||
+            extract_attributes_hash(node1)
+          attrs2 = diff_node.attributes_after ||
+            extract_attributes_hash(node2)
+
+          order1 = attrs1.keys.join(", ")
+          order2 = attrs2.keys.join(", ")
+
+          output << "#{prefix}├── #{colorize(
+            "- [#{order1}]",
+            theme_color(:removed, :content) || :red,
+          )}"
+          output << "#{prefix}└── #{colorize(
+            "+ [#{order2}]",
+            theme_color(:added, :content) || :green,
+          )}"
+        end
+
+        # Extract attributes hash from a node
+        def extract_attributes_hash(node)
+          return {} unless node
+
+          Canon::Diff::NodeSerializer.extract_attributes(node) || {}
+        end
+
+        # Find attributes that differ between two attribute hashes
+        def find_differing_attributes(attrs1, attrs2)
+          (attrs1.keys | attrs2.keys).reject do |k|
+            attrs1[k.to_s] == attrs2[k.to_s]
+          end.sort
+        end
+
         # Render unequal elements
         def render_unequal_elements(diff, prefix, output)
           node1 = diff[:node1]

data/lib/canon/diff_formatter/by_object_formatter.rb

@@ -21,9 +21,6 @@ module Canon
       # @param format [Symbol] Document format (:xml, :json, :yaml)
       # @return [String] Formatted diff output
       def format(differences, format)
-        output = []
-        output << colorize("Visual Diff:", :cyan, :bold)
-
         diffs_array = if differences.is_a?(Canon::Comparison::ComparisonResult)
                         differences.differences
                       else
@@ -37,8 +34,7 @@ module Canon
           show_diffs: @show_diffs,
         )
 
-        output << formatter.format(diffs_array, format)
-        output.join("\n")
+        formatter.format(diffs_array, format)
       end
 
       private

data/lib/canon/diff_formatter/diff_detail_formatter/dimension_formatter.rb

@@ -707,7 +707,7 @@ expand_difference: false)
         # @param diff [DiffNode, Hash] Difference node
         # @return [Symbol] Dimension
         def self.extract_dimension(diff)
-          if diff.respond_to?(:dimension)
+          if diff.is_a?(Canon::Diff::DiffNode)
             diff.dimension
           elsif diff.is_a?(Hash)
             diff[:dimension] || diff[:diff_code] || :unknown
@@ -721,7 +721,7 @@ expand_difference: false)
         # @param diff [DiffNode, Hash] Difference node
         # @return [Object] Node1
         def self.extract_node1(diff)
-          if diff.respond_to?(:node1)
+          if diff.is_a?(Canon::Diff::DiffNode)
             diff.node1
           elsif diff.is_a?(Hash)
             diff[:node1]
@@ -733,7 +733,7 @@ expand_difference: false)
         # @param diff [DiffNode, Hash] Difference node
         # @return [Object] Node2
         def self.extract_node2(diff)
-          if diff.respond_to?(:node2)
+          if diff.is_a?(Canon::Diff::DiffNode)
             diff.node2
           elsif diff.is_a?(Hash)
             diff[:node2]

data/lib/canon/diff_formatter/diff_detail_formatter/location_extractor.rb

@@ -17,12 +17,12 @@ module Canon
           return "" unless diff
 
           # Prefer pre-computed path if available (populated by MetadataEnricher)
-          if diff.respond_to?(:path) && !diff.path.nil? && !diff.path.empty?
-            return "Location: #{diff.path}"
+          if diff.is_a?(Canon::Diff::DiffNode) && diff.path && !diff.path.empty?
+            return diff.path
           end
 
           # Fall back to extracting from nodes
-          node = if diff.respond_to?(:node1)
+          node = if diff.is_a?(Canon::Diff::DiffNode)
                    diff.node1 || diff.node2
                  elsif diff.is_a?(Hash)
                    diff[:node1] || diff[:node2]
@@ -30,8 +30,7 @@ module Canon
 
           return "" unless node
 
-          xpath = extract_xpath(node)
-          xpath.empty? ? "" : "Location: #{xpath}"
+          extract_xpath(node)
         end
 
         # Extract XPath from a node
@@ -66,24 +65,26 @@ module Canon
           current = node
 
           while current
-            break unless current.respond_to?(:name)
-
-            name = current.name
+            name = case current
+                   when Canon::Xml::Node, Nokogiri::XML::Node
+                     current.name
+                   else
+                     break
+                   end
             break if name.nil? || name.empty?
 
-            # Calculate position among siblings
             index = calculate_sibling_index(current, name)
             parts.unshift("#{name}[#{index}]")
 
-            # Move to parent
-            current = if current.respond_to?(:parent)
+            current = case current
+                      when Canon::Xml::Node, Nokogiri::XML::Node
                         current.parent
-                      elsif current.respond_to?(:parent_node)
-                        current.parent_node
+                      else
+                        break
                       end
 
-            # Stop at document root
-            break if current.respond_to?(:document) && current == current.document
+            break if current.is_a?(Nokogiri::XML::Document) ||
+              current.is_a?(Canon::Xml::Nodes::RootNode)
           end
 
           parts.empty? ? "" : "/#{parts.join('/')}"
@@ -95,24 +96,22 @@ module Canon
         # @param name [String] Node name
         # @return [Integer] 1-based index
         def self.calculate_sibling_index(node, name)
-          return 1 unless node.respond_to?(:parent) || node.respond_to?(:parent_node)
-
-          parent = if node.respond_to?(:parent)
+          parent = case node
+                   when Canon::Xml::Node, Nokogiri::XML::Node
                      node.parent
-                   elsif node.respond_to?(:parent_node)
-                     node.parent_node
                    end
 
           return 1 unless parent
 
-          # Get siblings with same name
-          siblings = if parent.respond_to?(:children)
+          siblings = case parent
+                     when Canon::Xml::Node, Nokogiri::XML::Node
                        parent.children.select do |n|
-                         n.respond_to?(:name) && n.name == name
-                       end
-                     elsif parent.respond_to?(:child_nodes)
-                       parent.child_nodes.select do |n|
-                         n.respond_to?(:name) && n.name == name
+                         case n
+                         when Canon::Xml::Node, Nokogiri::XML::Node
+                           n.name == name
+                         else
+                           false
+                         end
                        end
                      else
                        [node]

data/lib/canon/diff_formatter.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require "paint" unless RUBY_ENGINE == "opal"
-require "yaml"
+require "yaml" unless RUBY_ENGINE == "opal"
 require_relative "comparison"
 require_relative "diff/diff_block"
 require_relative "diff/diff_context"
@@ -135,16 +135,17 @@ module Canon
     end
 
     # Default character visualization map (loaded from YAML)
-    DEFAULT_VISUALIZATION_MAP = character_map_data[:visualization_map].freeze
-
-    # Character category map (loaded from YAML)
-    CHARACTER_CATEGORY_MAP = character_map_data[:category_map].freeze
-
-    # Category display names (loaded from YAML)
-    CHARACTER_CATEGORY_NAMES = character_map_data[:category_names].freeze
-
-    # Character metadata including names (loaded from YAML)
-    CHARACTER_METADATA = character_map_data[:character_metadata].freeze
+    if RUBY_ENGINE == "opal"
+      DEFAULT_VISUALIZATION_MAP = {}.freeze
+      CHARACTER_CATEGORY_MAP = {}.freeze
+      CHARACTER_CATEGORY_NAMES = {}.freeze
+      CHARACTER_METADATA = {}.freeze
+    else
+      DEFAULT_VISUALIZATION_MAP = character_map_data[:visualization_map].freeze
+      CHARACTER_CATEGORY_MAP = character_map_data[:category_map].freeze
+      CHARACTER_CATEGORY_NAMES = character_map_data[:category_names].freeze
+      CHARACTER_METADATA = character_map_data[:character_metadata].freeze
+    end
 
     # Map difference codes to human-readable descriptions
     DIFF_DESCRIPTIONS = {
@@ -757,6 +758,9 @@ module Canon
       output.join("\n")
     end
 
+    public :format_line_numbered_inputs, :format_raw_inputs,
+           :format_preprocessed_inputs
+
     # Build the final visualization map from various customization options
     #
     # @param visualization_map [Hash, nil] Complete custom visualization map

data/lib/canon/html/data_model.rb

@@ -89,7 +89,7 @@ module Canon
       def self.build_from_nokogiri(nokogiri_doc)
         root = Canon::Xml::Nodes::RootNode.new
 
-        if nokogiri_doc.respond_to?(:root) && nokogiri_doc.root
+        if nokogiri_doc.is_a?(Nokogiri::XML::Document) && nokogiri_doc.root
           # For Documents (HTML4, HTML5): process the root element
           root.add_child(build_element_node(nokogiri_doc.root))
 

data/lib/canon/tree_diff/operation_converter.rb

@@ -124,6 +124,8 @@ module Canon
         end
       end
 
+      public :convert_operation
+
       # Convert INSERT operation to DiffNode
       #
       # @param operation [Operation] Insert operation
@@ -153,7 +155,7 @@ module Canon
 
       # Determine dimension for INSERT/DELETE operations based on node type
       def dimension_for_insert_delete(tree_node)
-        label = tree_node.respond_to?(:label) ? tree_node.label : nil
+        label = tree_node.is_a?(Canon::TreeDiff::Core::TreeNode) ? tree_node.label : nil
         return :comments if label == "comment"
 
         :element_structure
@@ -359,7 +361,7 @@ module Canon
       def extract_source_node(tree_node)
         return nil if tree_node.nil?
 
-        tree_node.respond_to?(:source_node) ? tree_node.source_node : tree_node
+        tree_node.is_a?(Canon::TreeDiff::Core::TreeNode) ? tree_node.source_node : tree_node
       end
 
       # Determine if a diff is normative based on match options
@@ -383,12 +385,10 @@ module Canon
         return false if node.nil?
 
         # Get element name from node
-        element_name = if node.respond_to?(:label)
-                         node.label # TreeNode
-                       elsif node.respond_to?(:name)
-                         node.name # Nokogiri node
+        element_name = if node.is_a?(Canon::TreeDiff::Core::TreeNode)
+                         node.label
                        else
-                         return false
+                         Canon::Comparison::NodeInspector.name(node)
                        end
 
         # Check if it's in our metadata elements list

data/lib/canon/tree_diff/operations/operation_detector.rb

@@ -600,6 +600,10 @@ module Canon
           depth
         end
 
+        public :normalize_text, :calculate_depth, :text_similarity,
+               :extract_text_content, :collect_all_nodes, :nodes_identical?,
+               :detect_changes
+
         # Check if a node is in a whitespace-sensitive context
         #
         # HTML elements where whitespace is significant: <pre>, <code>, <textarea>, <script>, <style>

data/lib/canon/validators/base_validator.rb

@@ -29,17 +29,14 @@ module Canon
         line = nil
         column = nil
 
-        # Try to extract line/column from error message
-        if error.respond_to?(:line)
+        if error.is_a?(Nokogiri::XML::SyntaxError)
           line = error.line
+          column = error.column
         elsif error.message =~ /line[:\s]+(\d+)/i
           line = ::Regexp.last_match(1).to_i
-        end
-
-        if error.respond_to?(:column)
-          column = error.column
-        elsif error.message =~ /column[:\s]+(\d+)/i
-          column = ::Regexp.last_match(1).to_i
+          if error.message =~ /column[:\s]+(\d+)/i
+            column = ::Regexp.last_match(1).to_i
+          end
         end
 
         { line: line, column: column }

data/lib/canon/validators/html_validator.rb

@@ -94,13 +94,8 @@ module Canon
       #
       # @param error [Nokogiri::XML::SyntaxError] The syntax error
       # @return [String, nil] Additional details about the error
-      def self.extract_details(error)
-        return nil unless error.respond_to?(:errors)
-
-        details = error.errors.map(&:message).reject do |msg|
-          msg == error.message
-        end
-        details.join("; ") unless details.empty?
+      def self.extract_details(_error)
+        nil
       end
 
       # Build error details from multiple errors

data/lib/canon/validators/xml_validator.rb

@@ -38,13 +38,8 @@ module Canon
       #
       # @param error [Nokogiri::XML::SyntaxError] The syntax error
       # @return [String, nil] Additional details about the error
-      def self.extract_details(error)
-        return nil unless error.respond_to?(:errors)
-
-        details = error.errors.map(&:message).reject do |msg|
-          msg == error.message
-        end
-        details.join("; ") unless details.empty?
+      def self.extract_details(_error)
+        nil
       end
 
       private_class_method :extract_details

data/lib/canon/version.rb

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

data/lib/canon/xml/data_model.rb

@@ -139,7 +139,7 @@ module Canon
       def self.build_from_nokogiri(nokogiri_doc, preserve_whitespace: false)
         root = Nodes::RootNode.new
 
-        if nokogiri_doc.respond_to?(:root) && nokogiri_doc.root
+        if nokogiri_doc.is_a?(Nokogiri::XML::Document) && nokogiri_doc.root
           root.add_child(build_element_node(nokogiri_doc.root,
                                             preserve_whitespace: preserve_whitespace))
           nokogiri_doc.children.each do |child|
@@ -275,7 +275,7 @@ preserve_whitespace: false)
       def self.build_from_moxml(moxml_doc, preserve_whitespace: false)
         root = Nodes::RootNode.new
 
-        if moxml_doc.respond_to?(:root) && moxml_doc.root
+        if moxml_doc.is_a?(Moxml::Document) && moxml_doc.root
           root.add_child(build_moxml_element_node(moxml_doc.root,
                                                   preserve_whitespace: preserve_whitespace))
         end
@@ -327,7 +327,7 @@ preserve_whitespace: false)
           element.add_namespace(ns_node)
         end
 
-        unless element.namespaces.any? do |n|
+        unless element.namespace_nodes.any? do |n|
           n.prefix == "xml"
         end
           element.add_namespace(Nodes::NamespaceNode.new(
@@ -348,7 +348,7 @@ preserve_whitespace: false)
       end
 
       def self.build_moxml_text_node(moxml_text, preserve_whitespace: false)
-        content = moxml_text.text
+        content = moxml_text.content
 
         if !preserve_whitespace && content.strip.empty? && moxml_text.parent.is_a?(Moxml::Element)
           return nil
@@ -358,7 +358,7 @@ preserve_whitespace: false)
       end
 
       def self.build_moxml_comment_node(moxml_comment)
-        Nodes::CommentNode.new(value: moxml_comment.text)
+        Nodes::CommentNode.new(value: moxml_comment.content)
       end
 
       def self.build_moxml_pi_node(moxml_pi)

data/lib/canon/xml/sax_builder.rb

@@ -28,7 +28,7 @@ module Canon
     # For C14N, use strip_doctype: true to avoid DTD default attribute expansion:
     #   root = SaxBuilder.parse(xml_string, strip_doctype: true)
     #
-    class SaxBuilder < Nokogiri::XML::SAX::Document
+    class SaxBuilder < (RUBY_ENGINE == "opal" ? Object : Nokogiri::XML::SAX::Document)
       # Parse XML string and return Canon::Xml::Node tree
       #
       # @param xml_string [String] XML content to parse

data/lib/canon/xml/whitespace_normalizer.rb

@@ -43,9 +43,9 @@ module Canon
       # @param node [Moxml::Node] Node to check
       # @return [Boolean] true if node is whitespace-only and should be ignored
       def inter_element_whitespace?(node)
-        return false unless node.respond_to?(:text?) && node.text?
+        return false unless node.is_a?(Nokogiri::XML::Text) || node.is_a?(Moxml::Text)
 
-        text = node.respond_to?(:content) ? node.content.to_s : node.text.to_s
+        text = node.is_a?(Moxml::Text) ? node.content.to_s : node.content.to_s
         text.strip.empty?
       end
 

data/lib/canon/xml_parsing.rb

@@ -14,7 +14,7 @@ module Canon
   module XmlParsing
     class << self
       def moxml_context
-        @moxml_context ||= Moxml.new(:oga)
+        @moxml_context ||= Moxml.new(RUBY_ENGINE == "opal" ? :rexml : :oga)
       end
 
       # --- Parsing ---
@@ -47,10 +47,15 @@ module Canon
       end
 
       # --- Type checks (backend-safe) ---
+      #
+      # Both Nokogiri and Moxml are loaded as dependencies. XmlBackend
+      # determines which is used for *parsing*, but nodes from either
+      # library may flow through comparison code (e.g. tests, format
+      # detection). Under Nokogiri backend, both types are checked.
 
       def document?(obj)
         if XmlBackend.nokogiri?
-          obj.is_a?(Nokogiri::XML::Document)
+          obj.is_a?(Nokogiri::XML::Document) || obj.is_a?(Moxml::Document)
         else
           obj.is_a?(Moxml::Document)
         end
@@ -58,7 +63,7 @@ module Canon
 
       def xml_node?(obj)
         if XmlBackend.nokogiri?
-          obj.is_a?(Nokogiri::XML::Node)
+          obj.is_a?(Nokogiri::XML::Node) || obj.is_a?(Moxml::Node)
         else
           obj.is_a?(Moxml::Node)
         end
@@ -66,7 +71,7 @@ module Canon
 
       def element?(node)
         if XmlBackend.nokogiri?
-          node.is_a?(Nokogiri::XML::Element)
+          node.is_a?(Nokogiri::XML::Element) || node.is_a?(Moxml::Element)
         else
           node.is_a?(Moxml::Element)
         end
@@ -74,7 +79,7 @@ module Canon
 
       def text_node?(node)
         if XmlBackend.nokogiri?
-          node.is_a?(Nokogiri::XML::Text)
+          node.is_a?(Nokogiri::XML::Text) || node.is_a?(Moxml::Text)
         else
           node.is_a?(Moxml::Text)
         end
@@ -82,7 +87,7 @@ module Canon
 
       def comment?(node)
         if XmlBackend.nokogiri?
-          node.is_a?(Nokogiri::XML::Comment)
+          node.is_a?(Nokogiri::XML::Comment) || node.is_a?(Moxml::Comment)
         else
           node.is_a?(Moxml::Comment)
         end
@@ -90,7 +95,7 @@ module Canon
 
       def cdata?(node)
         if XmlBackend.nokogiri?
-          node.is_a?(Nokogiri::XML::CDATA)
+          node.is_a?(Nokogiri::XML::CDATA) || node.is_a?(Moxml::Cdata)
         else
           node.is_a?(Moxml::Cdata)
         end
@@ -98,7 +103,7 @@ module Canon
 
       def processing_instruction?(node)
         if XmlBackend.nokogiri?
-          node.is_a?(Nokogiri::XML::ProcessingInstruction)
+          node.is_a?(Nokogiri::XML::ProcessingInstruction) || node.is_a?(Moxml::ProcessingInstruction)
         else
           node.is_a?(Moxml::ProcessingInstruction)
         end
@@ -108,7 +113,7 @@ module Canon
         if XmlBackend.nokogiri?
           obj.is_a?(Nokogiri::XML::DocumentFragment)
         else
-          obj.is_a?(Moxml::DocumentFragment)
+          false
         end
       end
 
@@ -142,7 +147,14 @@ module Canon
         if XmlBackend.nokogiri?
           node.is_a?(Nokogiri::XML::Node) ? node.content : node.to_s
         else
-          node.is_a?(Moxml::Node) ? node.text : node.to_s
+          case node
+          when Moxml::Text, Moxml::Cdata, Moxml::Comment
+            node.content.to_s
+          when Moxml::Node
+            node.text.to_s
+          else
+            node.to_s
+          end
         end
       end
 
@@ -257,12 +269,12 @@ module Canon
       end
 
       def moxml_node_type(node)
-        return :element if node.is_a?(Moxml::Element)
-        return :text if node.is_a?(Moxml::Text)
-        return :comment if node.is_a?(Moxml::Comment)
-        return :cdata if node.is_a?(Moxml::Cdata)
-        return :document if node.is_a?(Moxml::Document)
-        return :processing_instruction if node.is_a?(Moxml::ProcessingInstruction)
+        return :element if node.element?
+        return :text if node.text?
+        return :comment if node.comment?
+        return :cdata if node.cdata?
+        return :document if node.document?
+        return :processing_instruction if node.processing_instruction?
 
         nil
       end