canon 0.2.8 → 0.2.9

data/lib/canon/xml_parsing.rb

@@ -0,0 +1,271 @@
+# frozen_string_literal: true
+
+module Canon
+  # Backend-agnostic XML parsing, serialization, and type dispatch.
+  #
+  # Provides a unified API that delegates to the active backend
+  # (Nokogiri or moxml/Oga). Uses backend-branching (`if XmlBackend.nokogiri?`)
+  # rather than `case/when` with constant references — this ensures Nokogiri
+  # constants are never resolved under Opal, preventing NameError at runtime.
+  #
+  # OCP: adding a new backend only requires updating this module.
+  # DRY: all backend dispatch centralized here, not scattered across
+  # comparator/formatter files.
+  module XmlParsing
+    class << self
+      def moxml_context
+        @moxml_context ||= Moxml.new(:oga)
+      end
+
+      # --- Parsing ---
+
+      def parse(xml_string, options = {})
+        if XmlBackend.nokogiri?
+          nokogiri_parse(xml_string, options)
+        else
+          moxml_parse(xml_string, options)
+        end
+      end
+
+      def parse_fragment(xml_string)
+        if XmlBackend.nokogiri?
+          Nokogiri::XML.fragment(xml_string).children.to_a
+        else
+          doc = moxml_context.parse("<__frag__>#{xml_string}</__frag__>")
+          doc.root.children.to_a
+        end
+      end
+
+      # --- Serialization ---
+
+      def serialize(node)
+        if XmlBackend.nokogiri?
+          nokogiri_serialize(node)
+        else
+          moxml_serialize(node)
+        end
+      end
+
+      # --- Type checks (backend-safe) ---
+
+      def document?(obj)
+        if XmlBackend.nokogiri?
+          obj.is_a?(Nokogiri::XML::Document)
+        else
+          obj.is_a?(Moxml::Document)
+        end
+      end
+
+      def xml_node?(obj)
+        if XmlBackend.nokogiri?
+          obj.is_a?(Nokogiri::XML::Node)
+        else
+          obj.is_a?(Moxml::Node)
+        end
+      end
+
+      def element?(node)
+        if XmlBackend.nokogiri?
+          node.is_a?(Nokogiri::XML::Element)
+        else
+          node.is_a?(Moxml::Element)
+        end
+      end
+
+      def text_node?(node)
+        if XmlBackend.nokogiri?
+          node.is_a?(Nokogiri::XML::Text)
+        else
+          node.is_a?(Moxml::Text)
+        end
+      end
+
+      def comment?(node)
+        if XmlBackend.nokogiri?
+          node.is_a?(Nokogiri::XML::Comment)
+        else
+          node.is_a?(Moxml::Comment)
+        end
+      end
+
+      def cdata?(node)
+        if XmlBackend.nokogiri?
+          node.is_a?(Nokogiri::XML::CDATA)
+        else
+          node.is_a?(Moxml::Cdata)
+        end
+      end
+
+      def processing_instruction?(node)
+        if XmlBackend.nokogiri?
+          node.is_a?(Nokogiri::XML::ProcessingInstruction)
+        else
+          node.is_a?(Moxml::ProcessingInstruction)
+        end
+      end
+
+      def document_fragment?(obj)
+        if XmlBackend.nokogiri?
+          obj.is_a?(Nokogiri::XML::DocumentFragment)
+        else
+          obj.is_a?(Moxml::DocumentFragment)
+        end
+      end
+
+      def dtd?(node)
+        if XmlBackend.nokogiri?
+          node.is_a?(Nokogiri::XML::DTD)
+        else
+          false
+        end
+      end
+
+      # --- Node traversal ---
+
+      def children(node)
+        if XmlBackend.nokogiri?
+          node.is_a?(Nokogiri::XML::Node) ? node.children.to_a : []
+        else
+          node.is_a?(Moxml::Node) ? node.children.to_a : []
+        end
+      end
+
+      def name(node)
+        if XmlBackend.nokogiri?
+          node.is_a?(Nokogiri::XML::Node) ? node.name : nil
+        else
+          node.is_a?(Moxml::Node) ? node.name : nil
+        end
+      end
+
+      def text_content(node)
+        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
+        end
+      end
+
+      def attributes(node)
+        if XmlBackend.nokogiri?
+          node.is_a?(Nokogiri::XML::Element) ? node.attributes.values : []
+        else
+          node.is_a?(Moxml::Element) ? node.attributes : []
+        end
+      end
+
+      def attribute_value(node, attr_name)
+        if XmlBackend.nokogiri?
+          node.is_a?(Nokogiri::XML::Element) ? node[attr_name.to_s] : nil
+        else
+          node.is_a?(Moxml::Element) ? node[attr_name.to_s] : nil
+        end
+      end
+
+      def namespace_definitions(node)
+        if XmlBackend.nokogiri?
+          node.is_a?(Nokogiri::XML::Element) ? node.namespace_definitions : []
+        else
+          node.is_a?(Moxml::Element) ? node.namespace_definitions : []
+        end
+      end
+
+      def parent(node)
+        return nil unless xml_node?(node)
+        # Document nodes have no parent
+        return nil if document?(node)
+
+        node.parent
+      end
+
+      def namespace_uri(node)
+        if XmlBackend.nokogiri?
+          node.namespace&.href if node.is_a?(Nokogiri::XML::Element)
+        elsif node.is_a?(Moxml::Element)
+          node.namespace_uri
+        end
+      end
+
+      # Returns a symbol for all backends (:element, :text, :comment, etc.)
+      # or nil for unrecognised nodes.
+      def node_type(node)
+        if XmlBackend.nokogiri?
+          nokogiri_node_type(node)
+        else
+          moxml_node_type(node)
+        end
+      end
+
+      def canonicalize(node, options = {})
+        if XmlBackend.nokogiri?
+          node.canonicalize(options)
+        else
+          moxml_canonicalize(node, options)
+        end
+      end
+
+      private
+
+      # --- Nokogiri backend ---
+
+      def nokogiri_type_map
+        @nokogiri_type_map ||= {
+          Nokogiri::XML::Node::ELEMENT_NODE => :element,
+          Nokogiri::XML::Node::TEXT_NODE => :text,
+          Nokogiri::XML::Node::CDATA_SECTION_NODE => :cdata,
+          Nokogiri::XML::Node::COMMENT_NODE => :comment,
+          Nokogiri::XML::Node::PI_NODE => :processing_instruction,
+          Nokogiri::XML::Node::DOCUMENT_NODE => :document,
+          Nokogiri::XML::Node::DOCUMENT_FRAG_NODE => :document_fragment,
+          Nokogiri::XML::Node::DTD_NODE => :dtd,
+          Nokogiri::XML::Node::ATTRIBUTE_NODE => :attribute,
+        }.freeze
+      end
+
+      def nokogiri_node_type(node)
+        return nil unless node.is_a?(Nokogiri::XML::Node)
+
+        nokogiri_type_map[node.node_type]
+      end
+
+      def nokogiri_parse(xml_string, options)
+        doc = Nokogiri::XML.parse(xml_string)
+        doc = doc.remove_namespaces! if options[:remove_namespaces]
+        doc
+      end
+
+      def nokogiri_serialize(node)
+        if node.is_a?(Nokogiri::XML::Document)
+          node.to_xml(encoding: "UTF-8")
+        else
+          node.to_xml
+        end
+      end
+
+      # --- Moxml backend ---
+
+      def moxml_parse(xml_string, _options)
+        moxml_context.parse(xml_string)
+      end
+
+      def moxml_serialize(node)
+        node.to_xml
+      end
+
+      def moxml_canonicalize(node, _options)
+        node.to_xml
+      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)
+
+        nil
+      end
+    end
+  end
+end

data/lib/canon.rb

@@ -2,6 +2,8 @@
 
 require_relative "canon/version"
 require_relative "canon/errors"
+require_relative "canon/xml_backend"
+require_relative "canon/xml_parsing"
 require_relative "canon/config"
 require_relative "canon/data_model"
 require_relative "canon/html"
@@ -13,7 +15,7 @@ require_relative "canon/formatters/html4_formatter"
 require_relative "canon/formatters/html5_formatter"
 require_relative "canon/comparison"
 
-require_relative "canon/rspec_matchers" if defined?(RSpec)
+require_relative "canon/rspec_matchers" if defined?(RSpec.configure)
 
 module Canon
   SUPPORTED_FORMATS = %i[xml yaml json html html4 html5 string].freeze

data/lib/tasks/benchmark_runner.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require "benchmark/ips"
-require "table_tennis"
+require "table_tennis" unless RUBY_ENGINE == "opal"
 
 # Ensure lib/ is on the load path regardless of tmp location
 lib_path = File.expand_path(File.join(__dir__, "..", "..", "lib"))

data/lib/tasks/performance_helpers.rb

@@ -4,7 +4,7 @@ require "json"
 require "open3"
 require "tmpdir"
 require "fileutils"
-require "table_tennis"
+require "table_tennis" unless RUBY_ENGINE == "opal"
 
 module PerformanceHelpers
   # ANSI color codes for terminal output

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: canon
 version: !ruby/object:Gem::Version
-  version: 0.2.8
+  version: 0.2.9
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-05-05 00:00:00.000000000 Z
+date: 2026-05-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: diff-lcs
@@ -148,6 +148,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".rspec"
+- ".rspec-opal"
 - ".rubocop.yml"
 - ".rubocop_todo.yml"
 - CODE_OF_CONDUCT.md
@@ -385,6 +386,8 @@ files:
 - lib/canon/xml/whitespace_normalizer.rb
 - lib/canon/xml/xml_base_handler.rb
 - lib/canon/xml/xpath_engine.rb
+- lib/canon/xml_backend.rb
+- lib/canon/xml_parsing.rb
 - lib/tasks/benchmark_runner.rb
 - lib/tasks/performance.rake
 - lib/tasks/performance_comparator.rb