canon 0.3.5 → 0.3.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8912c851a2e2b0e250fcae120cda428d7705f9c6262b57ec7fe1218aaf186229
-  data.tar.gz: 98a7b6c64818395e18c1de7b8918255368b6b4bf8766ecaa567b5502c7c084b4
+  metadata.gz: 04012234db38cae77206ba33f856aca1262a0ad0111e7d233d5b814e90c22187
+  data.tar.gz: 3700758afcb5619f59ba7e2f896963bc63695d534f60af7d922dfce8c26076ec
 SHA512:
-  metadata.gz: 2fee687e2469d42193c4f58a294179dc8332aca3fefca5c3ad476cdc061e40c2370d2183790b20c1e43ae83b420ae78567cf7f27114c128f21b0ab8d76be46fe
-  data.tar.gz: 61a58938d48f48ce066c93b09e734bc62a05cfccec1c7fea80ecdb4de97663e589940108f89f0d8f947737d096ca9c21b9f41edbe51569da5bcc2ad5c990fd0f
+  metadata.gz: c6452b462325e65c3f38f31438656b1cf60790646413314d8e835f6a27f78026bc10de2474065627b26a602962c424fd6858e1bc97ed3bca43e8a009b1779291
+  data.tar.gz: 749b78e282b4b2c7d440f9dff4a2361ee8d7742afcdab54b490bf836ae9417afc5f677e2039143020a6e50eceaf12d42950372c7a5f62dfcd335223243962fef

data/lib/canon/html/data_model.rb

@@ -80,7 +80,7 @@ module Canon
       # fragment — a TreeBuilder walk like the XML extractors, with the
       # HTML whitespace policy and xmlns-free attributes.
       def self.build_from_nokogiri(nokogiri_doc)
-        builder = Canon::Xml::TreeBuilder.new
+        builder = Canon::Xml::TreeBuilder::DEFAULT
         root = Canon::Xml::Nodes::RootNode.new
         skip_types = defined?(Nokogiri) ? [Nokogiri::XML::DTD] : []
 

data/lib/canon/version.rb

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

data/lib/canon/xml/data_model.rb

@@ -134,8 +134,6 @@ module Canon
       # node kinds, document ordering) live in TreeBuilder and
       # WhitespacePolicy — one dialect, three feeds.
 
-      TREE_BUILDER = TreeBuilder.new
-
       # -- Nokogiri walk: top-down, scope flows down the recursion --
 
       def self.build_from_nokogiri(nokogiri_doc, preserve_whitespace: false)
@@ -145,13 +143,13 @@ module Canon
         if nokogiri_doc.is_a?(Nokogiri::XML::Document) && nokogiri_doc.root
           root.add_child(walk_nokogiri(nokogiri_doc.root,
                                        preserve_whitespace: preserve_whitespace))
-          TREE_BUILDER.add_document_children(root, nokogiri_doc.children,
-                                             nokogiri_doc.root, skip_types) do |child|
+          TreeBuilder::DEFAULT.add_document_children(root, nokogiri_doc.children,
+                                                     nokogiri_doc.root, skip_types) do |child|
             walk_nokogiri(child, preserve_whitespace: preserve_whitespace)
           end
         else
-          TREE_BUILDER.add_document_children(root, nokogiri_doc.children,
-                                             nil, skip_types) do |child|
+          TreeBuilder::DEFAULT.add_document_children(root, nokogiri_doc.children,
+                                                     nil, skip_types) do |child|
             walk_nokogiri(child, preserve_whitespace: preserve_whitespace)
           end
         end
@@ -163,11 +161,11 @@ module Canon
 inherited_namespaces: nil)
         case node
         when Nokogiri::XML::Element
-          scope = TREE_BUILDER.merge_namespace_scope(
+          scope = TreeBuilder::DEFAULT.merge_namespace_scope(
             inherited_namespaces,
             node.namespace_definitions.map { |ns| [ns.prefix, ns.href] },
           )
-          element = TREE_BUILDER.element(
+          element = TreeBuilder::DEFAULT.element(
             name: node.name,
             prefix: node.namespace&.prefix,
             namespace_uri: node.namespace&.href,
@@ -184,17 +182,17 @@ inherited_namespaces: nil)
           end
           element
         when Nokogiri::XML::Text, Nokogiri::XML::CDATA
-          TREE_BUILDER.text(node.content,
-                            keep: WhitespacePolicy.keep_dom_text?(
-                              node.content,
-                              preserve_whitespace: preserve_whitespace,
-                              element_parent: node.parent.is_a?(Nokogiri::XML::Element),
-                            ),
-                            original: node.to_xml)
+          TreeBuilder::DEFAULT.text(node.content,
+                                    keep: WhitespacePolicy.keep_dom_text?(
+                                      node.content,
+                                      preserve_whitespace: preserve_whitespace,
+                                      element_parent: node.parent.is_a?(Nokogiri::XML::Element),
+                                    ),
+                                    original: node.to_xml)
         when Nokogiri::XML::Comment
-          TREE_BUILDER.comment(node.content)
+          TreeBuilder::DEFAULT.comment(node.content)
         when Nokogiri::XML::ProcessingInstruction
-          TREE_BUILDER.processing_instruction(node.name, node.content)
+          TreeBuilder::DEFAULT.processing_instruction(node.name, node.content)
         end
       end
 
@@ -243,13 +241,13 @@ inherited_namespaces: nil)
           element = build_moxml_subtree_from_records(moxml_doc.root,
                                                      preserve_whitespace: preserve_whitespace)
           root.add_child(element) if element
-          TREE_BUILDER.add_document_children(root, moxml_doc.children,
-                                             moxml_doc.root, skip_types) do |child|
+          TreeBuilder::DEFAULT.add_document_children(root, moxml_doc.children,
+                                                     moxml_doc.root, skip_types) do |child|
             walk_moxml(child, preserve_whitespace: preserve_whitespace)
           end
         else
-          TREE_BUILDER.add_document_children(root, moxml_doc.children,
-                                             nil, skip_types) do |child|
+          TreeBuilder::DEFAULT.add_document_children(root, moxml_doc.children,
+                                                     nil, skip_types) do |child|
             walk_moxml(child, preserve_whitespace: preserve_whitespace)
           end
         end
@@ -276,15 +274,15 @@ preserve_whitespace: false)
                                                    own_namespaces)
                  when :text, :cdata
                    content = record[:text].to_s
-                   TREE_BUILDER.text(content,
-                                     keep: WhitespacePolicy.keep_dom_text?(
-                                       content, preserve_whitespace: preserve_whitespace
-                                     ))
+                   TreeBuilder::DEFAULT.text(content,
+                                             keep: WhitespacePolicy.keep_dom_text?(
+                                               content, preserve_whitespace: preserve_whitespace
+                                             ))
                  when :comment
-                   TREE_BUILDER.comment(record[:text])
+                   TreeBuilder::DEFAULT.comment(record[:text])
                  when :processing_instruction
-                   TREE_BUILDER.processing_instruction(record[:qname],
-                                                       record[:text] || "")
+                   TreeBuilder::DEFAULT.processing_instruction(record[:qname],
+                                                               record[:text] || "")
                  end
 
           frames.push([record[:depth], node]) if node
@@ -298,7 +296,7 @@ preserve_whitespace: false)
       end
 
       def self.build_moxml_element_from_record(record, frames, own_namespaces)
-        element = TREE_BUILDER.element(
+        element = TreeBuilder::DEFAULT.element(
           name: record[:qname],
           prefix: record[:prefix],
           namespace_uri: record[:namespace_uri],
@@ -316,9 +314,9 @@ preserve_whitespace: false)
       end
 
       def self.assign_moxml_namespace_scopes(element, inherited, own_namespaces)
-        scope = TREE_BUILDER.merge_namespace_scope(inherited,
-                                                   own_namespaces[element].to_a)
-        TREE_BUILDER.attach_namespace_scope(element, scope)
+        scope = TreeBuilder::DEFAULT.merge_namespace_scope(inherited,
+                                                           own_namespaces[element].to_a)
+        TreeBuilder::DEFAULT.attach_namespace_scope(element, scope)
 
         element.children.each do |child|
           assign_moxml_namespace_scopes(child, scope, own_namespaces) if child.is_a?(Nodes::ElementNode)
@@ -331,11 +329,11 @@ preserve_whitespace: false)
 inherited_namespaces: nil)
         case node
         when Moxml::Element
-          scope = TREE_BUILDER.merge_namespace_scope(
+          scope = TreeBuilder::DEFAULT.merge_namespace_scope(
             inherited_namespaces,
             node.namespace_definitions.map { |ns| [ns.prefix, ns.uri] },
           )
-          element = TREE_BUILDER.element(
+          element = TreeBuilder::DEFAULT.element(
             name: node.name,
             prefix: node.namespace&.prefix,
             namespace_uri: node.namespace&.uri,
@@ -352,16 +350,16 @@ inherited_namespaces: nil)
           end
           element
         when Moxml::Text, Moxml::Cdata
-          TREE_BUILDER.text(node.content,
-                            keep: WhitespacePolicy.keep_dom_text?(
-                              node.content,
-                              preserve_whitespace: preserve_whitespace,
-                              element_parent: node.parent.is_a?(Moxml::Element),
-                            ))
+          TreeBuilder::DEFAULT.text(node.content,
+                                    keep: WhitespacePolicy.keep_dom_text?(
+                                      node.content,
+                                      preserve_whitespace: preserve_whitespace,
+                                      element_parent: node.parent.is_a?(Moxml::Element),
+                                    ))
         when Moxml::Comment
-          TREE_BUILDER.comment(node.content)
+          TreeBuilder::DEFAULT.comment(node.content)
         when Moxml::ProcessingInstruction
-          TREE_BUILDER.processing_instruction(node.target, node.content)
+          TreeBuilder::DEFAULT.processing_instruction(node.target, node.content)
         end
       end
     end

data/lib/canon/xml/sax_builder.rb

@@ -9,6 +9,11 @@ module Canon
     # selects the driver. Much faster than DOM parsing + conversion —
     # no intermediate engine DOM tree, no traversal conversion pass.
     #
+    # Construction goes through TreeBuilder like every other feed:
+    # this class owns only what is SAX-specific — qname parsing, xmlns
+    # separation, character-reference decoding, adjacency combining,
+    # the namespace stack, and document-level reordering.
+    #
     # Usage:
     #   root = SaxBuilder.parse(xml_string, preserve_whitespace: false)
     #   # root is a Canon::Xml::Nodes::RootNode
@@ -123,26 +128,23 @@ strip_doctype: false)
           end
         end
 
-        # Push new namespace scope with declarations
+        # Push new namespace scope with declarations (own shadows
+        # inherited — the same merge the TreeBuilder scope kernel applies)
         new_scope = @namespace_stack.last.merge(ns_hash)
         @namespace_stack.push(new_scope)
 
-        # Find namespace URI from current scope
-        ns_uri = new_scope[prefix.to_s]
-
-        # Create element node
-        element = Nodes::ElementNode.new(
+        element = TreeBuilder::DEFAULT.element(
           name: local_name,
-          namespace_uri: ns_uri,
           prefix: prefix,
+          namespace_uri: new_scope[prefix.to_s],
+          namespace_scope: new_scope,
+          attributes: regular_attrs.map do |attr_name, attr_value|
+            attr_prefix, attr_local = parse_qname(attr_name)
+            attr_ns_uri = attr_prefix ? new_scope[attr_prefix] : nil
+            [attr_local, decode_character_references(attr_value || ""), attr_ns_uri, attr_prefix]
+          end,
         )
 
-        # Add namespace nodes from current scope
-        add_namespace_nodes(element, new_scope)
-
-        # Build and add attribute nodes (excluding xmlns declarations)
-        add_attribute_nodes(element, regular_attrs)
-
         parent.add_child(element)
         @stack.push(element)
       end
@@ -206,8 +208,9 @@ strip_doctype: false)
                                                       preserve_whitespace: @preserve_whitespace,
                                                       element_parent: parent.node_type == :element)
 
-        text = Nodes::TextNode.new(value: decoded_string, original: raw_string)
-        parent.add_child(text)
+        parent.add_child(
+          TreeBuilder::DEFAULT.text(decoded_string, keep: true, original: raw_string),
+        )
       end
       private :append_text
 
@@ -215,9 +218,7 @@ strip_doctype: false)
       #
       # @param string [String] Comment content
       def comment(string)
-        parent = @stack.last
-        comment_node = Nodes::CommentNode.new(value: string)
-        parent.add_child(comment_node)
+        @stack.last.add_child(TreeBuilder::DEFAULT.comment(string))
       end
 
       # Called for processing instructions
@@ -225,10 +226,9 @@ strip_doctype: false)
       # @param name [String] PI target
       # @param content [String] PI content
       def processing_instruction(name, content)
-        parent = @stack.last
-        pi = Nodes::ProcessingInstructionNode.new(target: name,
-                                                  data: content || "")
-        parent.add_child(pi)
+        @stack.last.add_child(
+          TreeBuilder::DEFAULT.processing_instruction(name, content || ""),
+        )
       end
 
       # Return the built tree
@@ -314,44 +314,7 @@ strip_doctype: false)
         [ns_decls, regular_attrs]
       end
 
-      # Add namespace nodes to element
-      #
-      # @param element [Nodes::ElementNode] Element to add namespaces to
-      # @param scope [Hash] Current namespace scope
-      def add_namespace_nodes(element, scope)
-        scope.each do |prefix, uri|
-          ns_node = Nodes::NamespaceNode.new(prefix: prefix, uri: uri)
-          element.add_namespace(ns_node)
-        end
-      end
-
-      # Add attribute nodes to element
-      #
-      # @param element [Nodes::ElementNode] Element to add attributes to
-      # @param attrs [Array] Array of [name, value] pairs
-      def add_attribute_nodes(element, attrs)
-        attrs.each do |attr_name, attr_value|
-          attr_prefix, attr_local = parse_qname(attr_name)
-
-          # Find namespace for attribute (if prefixed)
-          attr_ns_uri = attr_prefix ? @namespace_stack.last[attr_prefix] : nil
-
-          # Decode numeric character references (e.g., & → &)
-          # Nokogiri SAX leaves these as-is, but we need them decoded for C14N
-          decoded_value = decode_character_references(attr_value || "")
-
-          attr_node = Nodes::AttributeNode.new(
-            name: attr_local,
-            value: decoded_value,
-            namespace_uri: attr_ns_uri,
-            prefix: attr_prefix,
-          )
-          element.add_attribute(attr_node)
-        end
-      end
-
-      # Decode numeric character references in a string
-      # Handles both &#decimal; and &#xhex; forms
+      # Decode numeric character references (e.g., & → &)
       #
       # @param value [String] String potentially containing character references
       # @return [String] String with character references decoded

data/lib/canon/xml/tree_builder.rb

@@ -16,6 +16,9 @@ module Canon
     # repeats, libleptris deduplicates), so the builder resolves them
     # once — first occurrence wins.
     class TreeBuilder
+      # Stateless module: one shared instance serves every feed.
+      DEFAULT = new
+
       NO_ATTRIBUTES = [].freeze
       XML_NAMESPACE_PREFIX = "xml"
       XML_NAMESPACE_URI = "http://www.w3.org/XML/1998/namespace"
@@ -54,12 +57,16 @@ module Canon
         )
         attach_namespace_scope(element, namespace_scope) if namespace_scope
 
-        seen = {}
-        attributes.each do |attr_name, value, attr_namespace_uri, attr_prefix|
-          key = [attr_name, attr_namespace_uri]
-          next if seen.key?(key)
+        # Duplicate (name, namespace) pairs are invalid XML — first
+        # occurrence wins. Attributes per element are few, so a pairwise
+        # scan beats a per-element seen-hash on allocation (this is the
+        # hot SAX path).
+        attributes.each_with_index do |(attr_name, value, attr_namespace_uri, attr_prefix), index|
+          duplicate = attributes[0...index].any? do |prior_name, _v, prior_ns, _p|
+            prior_name == attr_name && prior_ns == attr_namespace_uri
+          end
+          next if duplicate
 
-          seen[key] = true
           element.add_attribute(Nodes::AttributeNode.new(
                                   name: attr_name,
                                   value: value,

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: canon
 version: !ruby/object:Gem::Version
-  version: 0.3.5
+  version: 0.3.6
 platform: ruby
 authors:
 - Ribose Inc.