RubyGems - makiri - Versions diffs - 0.2.0-aarch64-linux → 0.3.0-aarch64-linux - Mend

makiri 0.2.0-aarch64-linux → 0.3.0-aarch64-linux

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (34) hide show

checksums.yaml +4 -4
data/.github/workflows/release.yml +12 -7
data/CHANGELOG.md +93 -14
data/README.md +173 -7
data/Rakefile +103 -7
data/lib/makiri/3.2/makiri.so +0 -0
data/lib/makiri/3.3/makiri.so +0 -0
data/lib/makiri/3.4/makiri.so +0 -0
data/lib/makiri/4.0/makiri.so +0 -0
data/lib/makiri/{attribute.rb → attr.rb} +7 -3
data/lib/makiri/cdata_section.rb +21 -0
data/lib/makiri/comment.rb +12 -0
data/lib/makiri/compat_aliases.rb +30 -0
data/lib/makiri/document.rb +4 -76
data/lib/makiri/document_fragment.rb +14 -9
data/lib/makiri/element.rb +5 -3
data/lib/makiri/html/document.rb +106 -0
data/lib/makiri/html/node_methods.rb +19 -0
data/lib/makiri/html.rb +12 -0
data/lib/makiri/node.rb +58 -15
data/lib/makiri/node_set.rb +8 -0
data/lib/makiri/processing_instruction.rb +12 -0
data/lib/makiri/text.rb +2 -0
data/lib/makiri/version.rb +1 -1
data/lib/makiri/xml/document.rb +24 -0
data/lib/makiri/xml/node_methods.rb +37 -0
data/lib/makiri/xml.rb +10 -0
data/lib/makiri/xpath_context.rb +1 -1
data/lib/makiri.rb +23 -5
data/script/build_native_gem.rb +2 -2
data/script/check_c_safety.rb +32 -0
data/script/check_c_safety_allowlist.yml +83 -0
metadata +10 -3
data/lib/makiri/cdata.rb +0 -6

data/lib/makiri/cdata_section.rb ADDED Viewed

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+module Makiri
+  # A CDATA section. The canonical name is the WHATWG DOM interface name
+  # CDATASection; Makiri::CDATA is a Nokogiri-compatible alias (see
+  # compat_aliases.rb).
+  class CDATASection < Node
+    # Create a detached CDATA section owned by +document+ (Nokogiri-style,
+    # document first). Delegates to {Document#create_cdata} - so XML only; HTML
+    # has no CDATA construction.
+    #
+    # @param document [Makiri::Document]
+    # @param content [String]
+    # @return [Makiri::CDATASection]
+    def self.new(document, content)
+      raise TypeError, "expected a Makiri::Document" unless document.is_a?(Makiri::Document)
+      document.create_cdata(content)
+    end
+  end
+end

data/lib/makiri/comment.rb CHANGED Viewed

@@ -2,5 +2,17 @@
 module Makiri
   class Comment < Node
+    # Create a detached comment owned by +document+ (Nokogiri-style constructor;
+    # the document comes FIRST for Comment / CDATASection / ProcessingInstruction, unlike
+    # Element / Text). Delegates to {Document#create_comment}.
+    #
+    # @param document [Makiri::Document]
+    # @param content [String]
+    # @return [Makiri::Comment]
+    def self.new(document, content)
+      raise TypeError, "expected a Makiri::Document" unless document.is_a?(Makiri::Document)
+      document.create_comment(content)
+    end
   end
 end

data/lib/makiri/compat_aliases.rb ADDED Viewed

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+module Makiri
+  # Nokogiri-compatible class-name aliases.
+  #
+  # Makiri's canonical node-class names are the WHATWG DOM interface names
+  # (Element, Attr, Text, Comment, CDATASection, ProcessingInstruction,
+  # DocumentType, Document, DocumentFragment). Two of those differ from the
+  # libxml2/Nokogiri spelling; we expose the Nokogiri names as aliases so a
+  # snippet ported from Nokogiri (or an is_a?/case check) resolves unchanged:
+  #
+  #   CDATASection  <- CDATA   (Nokogiri::XML::CDATA)
+  #   DocumentType  <- DTD     (Nokogiri::XML::DTD)
+  #
+  # An alias is the same class object, so #is_a? works under either name; only
+  # #class.name (and inspect) report the canonical DOM name. Defined at all three
+  # levels (the abstract base and the HTML::/XML:: leaves).
+  CDATA = CDATASection
+  DTD = DocumentType
+  module HTML
+    CDATA = CDATASection
+    DTD = DocumentType
+  end
+  module XML
+    CDATA = CDATASection
+    DTD = DocumentType
+  end
+end

data/lib/makiri/document.rb CHANGED Viewed

@@ -1,82 +1,10 @@
 # frozen_string_literal: true
 module Makiri
-  # Root container for a parsed HTML document.
+  # Abstract base for a parsed document (§12). Concrete documents are the
+  # per-kind leaves: {Makiri::HTML::Document} (HTML5) and
+  # {Makiri::XML::Document} (XML). `is_a?(Makiri::Document)` is true for both.
+  # Construction and the HTML-only conveniences live on the leaves, not here.
   class Document < Node
-    # Parse +source+ as HTML5 and return a Document.
-    #
-    # +source+ may be a String or any object responding to +#read+ (e.g. an
-    # IO). The native parser (#_parse) expects UTF-8 bytes. Source locations
-    # for {Node#line} are always tracked (the cost is negligible).
-    #
-    # @param source [String, #read]
-    # @return [Makiri::Document]
-    def self.parse(source)
-      source = source.read if source.respond_to?(:read)
-      _parse(String(source))
-    end
-    # The document's <body> element, or nil.
-    # @return [Makiri::Element, nil]
-    def body
-      at_css("body")
-    end
-    # The document's <head> element, or nil.
-    # @return [Makiri::Element, nil]
-    def head
-      at_css("head")
-    end
-    # Set the document title, creating <title> (in <head>) if absent.
-    # @param text [String]
-    # @return [String]
-    def title=(text)
-      t = at_css("title")
-      unless t
-        t = Element.new("title", self)
-        (head || root).add_child(t)
-      end
-      t.content = text
-      text
-    end
-    # Makiri parses and stores everything as UTF-8 (callers decode bytes before
-    # parsing), so the in-memory encoding is always UTF-8.
-    # @return [String]
-    def encoding
-      "UTF-8"
-    end
-    # The charset declared in the document's markup, or nil. Reads
-    # <meta charset> first, then <meta http-equiv="Content-Type">.
-    # @return [String, nil]
-    def meta_encoding
-      if (m = at_css("meta[charset]"))
-        return m["charset"]
-      end
-      css("meta").each do |meta|
-        http_equiv = meta["http-equiv"]
-        next unless http_equiv&.downcase == "content-type"
-        content = meta["content"].to_s
-        return Regexp.last_match(1) if content =~ /charset\s*=\s*"?([^\s;"]+)/i
-      end
-      nil
-    end
-    # Set (or insert) a <meta charset> declaration.
-    # @param value [String]
-    # @return [String]
-    def meta_encoding=(value)
-      meta = at_css("meta[charset]")
-      unless meta
-        meta = Element.new("meta", self)
-        (head || root).add_child(meta)
-      end
-      meta["charset"] = value
-      value
-    end
   end
 end

data/lib/makiri/document_fragment.rb CHANGED Viewed

@@ -6,16 +6,21 @@ module Makiri
   # its nodes can be spliced in with {Node#add_child} and friends). Inserting a
   # fragment contributes its children, not the fragment node itself.
   #
-  # Both +.parse+ and +Document#fragment+ accept a Nokogiri-compatible
-  # <tt>context:</tt> keyword naming the element the HTML is parsed inside of
-  # (the fragment-parsing algorithm is context-sensitive). It may be:
-  #   * a tag-name String (HTML namespace), e.g. <tt>context: "tr"</tt>; the
-  #     bare strings <tt>"svg"</tt> / <tt>"math"</tt> name the foreign roots;
-  #   * a {Makiri::Node} element — its tag and namespace are used (the way to
-  #     reach a foreign non-root context such as an SVG <desc>).
-  # The default context is <tt><body></tt>. See also {Makiri::Node#parse}.
+  # The concrete classes are {Makiri::HTML::DocumentFragment} and
+  # {Makiri::XML::DocumentFragment}; their fragment-parsing context differs:
   #
-  # +.parse+ is defined in C (ext/makiri/glue/ruby_doc.c).
+  # * HTML is context-sensitive: <tt>.parse</tt> / <tt>Document#fragment</tt>
+  #   accept a Nokogiri-compatible <tt>context:</tt> keyword naming the element
+  #   the HTML is parsed inside of - a tag-name String (HTML namespace, e.g.
+  #   <tt>context: "tr"</tt>; the bare strings <tt>"svg"</tt> / <tt>"math"</tt>
+  #   name the foreign roots), or a {Makiri::Node} element whose tag and namespace
+  #   are used. The default context is <tt><body></tt>. (Defined in C, ruby_html_*.c.)
+  # * XML is namespace-context-based (no <tt>context:</tt> keyword):
+  #   {Makiri::XML::DocumentFragment.parse} is self-contained (a prefix must be
+  #   declared within the fragment itself), while {Makiri::XML::Document#fragment}
+  #   resolves names against the document's in-scope namespaces. (C: ruby_xml.c.)
+  #
+  # See also {Makiri::Node#parse}.
   class DocumentFragment < Node
   end
 end

data/lib/makiri/element.rb CHANGED Viewed

@@ -1,16 +1,18 @@
 # frozen_string_literal: true
 module Makiri
-  # An HTML element node. Attribute access lives in C.
+  # An element node (HTML or XML). Attribute access lives in C.
   class Element < Node
     # Create a detached element named +name+ owned by +document+ (Nokogiri-style
-    # constructor; delegates to {Document#create_element}). Attach it with
-    # {Node#add_child} and friends.
+    # constructor; delegates to {Document#create_element}, so its representation
+    # follows the document). Attach it with {Node#add_child} and friends.
     #
     # @param name [String]
     # @param document [Makiri::Document]
     # @return [Makiri::Element]
     def self.new(name, document)
+      raise TypeError, "expected a Makiri::Document" unless document.is_a?(Makiri::Document)
       document.create_element(name)
     end
   end

data/lib/makiri/html/document.rb ADDED Viewed

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+module Makiri
+  module HTML
+    # Root container for a parsed HTML document. Construction, serialization and
+    # the HTML-only conveniences (body/head/title/encoding) live here, not on the
+    # abstract Makiri::Document.
+    class Document
+      # Parse +source+ as HTML5 and return a Makiri::HTML::Document.
+      #
+      # +source+ may be a String or any object responding to +#read+ (e.g. an
+      # IO). The native parser (#_parse) expects UTF-8 bytes. Source locations
+      # for {Node#line} are always tracked (the cost is negligible).
+      #
+      # @param source [String, #read]
+      # @return [Makiri::HTML::Document]
+      def self.parse(source)
+        source = source.read if source.respond_to?(:read)
+        _parse(String(source))
+      end
+      # An independent copy of the whole document (like Nokogiri's Document#dup).
+      # Built by serialising and re-parsing, so the copy shares no nodes with the
+      # original - Node#dup's clone_node delegation is wrong for a document node,
+      # hence this override. (A DOM mutated into a shape the HTML parser would not
+      # itself produce, e.g. a foster-parented table cell, may be re-normalised on
+      # re-parse; a freshly parsed document round-trips unchanged.) Any level /
+      # freeze argument is ignored.
+      def dup(*)
+        Makiri.parse(to_html)
+      end
+      # Like {#dup}: an independent copy of the document, honouring Ruby's
+      # +freeze:+ keyword (a frozen document's nodes raise +FrozenError+ on
+      # mutation).
+      def clone(freeze: nil)
+        copy = Makiri.parse(to_html)
+        copy.freeze if freeze || (freeze.nil? && frozen?)
+        copy
+      end
+      # The document's <body> element, or nil.
+      # @return [Makiri::Element, nil]
+      def body
+        at_css("body")
+      end
+      # The document's <head> element, or nil.
+      # @return [Makiri::Element, nil]
+      def head
+        at_css("head")
+      end
+      # Set the document title, creating <title> (in <head>) if absent.
+      # @param text [String]
+      # @return [String]
+      def title=(text)
+        t = at_css("title")
+        unless t
+          t = Element.new("title", self)
+          (head || root).add_child(t)
+        end
+        t.content = text
+        text
+      end
+      # Makiri parses and stores everything as UTF-8 (callers decode bytes before
+      # parsing), so the in-memory encoding is always UTF-8.
+      # @return [String]
+      def encoding
+        "UTF-8"
+      end
+      # The charset declared in the document's markup, or nil. Reads
+      # <meta charset> first, then <meta http-equiv="Content-Type">.
+      # @return [String, nil]
+      def meta_encoding
+        if (m = at_css("meta[charset]"))
+          return m["charset"]
+        end
+        css("meta").each do |meta|
+          http_equiv = meta["http-equiv"]
+          next unless http_equiv&.downcase == "content-type"
+          content = meta["content"].to_s
+          return Regexp.last_match(1) if content =~ /charset\s*=\s*"?([^\s;"]+)/i
+        end
+        nil
+      end
+      # Set (or insert) a <meta charset> declaration.
+      # @param value [String]
+      # @return [String]
+      def meta_encoding=(value)
+        meta = at_css("meta[charset]")
+        unless meta
+          meta = Element.new("meta", self)
+          (head || root).add_child(meta)
+        end
+        meta["charset"] = value
+        value
+      end
+    end
+  end
+end

data/lib/makiri/html/node_methods.rb ADDED Viewed

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+module Makiri
+  module HTML
+    # The lxb_dom reader/query methods are defined in C on this module and
+    # included into every HTML leaf (including the generic Makiri::HTML::Node).
+    # The Nokogiri-compatible aliases over those readers live here (not on
+    # Makiri::Node) so they resolve against the HTML readers at definition time.
+    module NodeMethods
+      alias_method :attr, :[]
+      alias_method :get_attribute, :[]
+      alias_method :has_attribute?, :key?
+      alias_method :remove_attribute, :delete
+      alias_method :node_name, :name
+      alias_method :node_name=, :name=
+      alias_method :type, :node_type
+    end
+  end
+end

data/lib/makiri/html.rb ADDED Viewed

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+module Makiri
+  # HTML-specific node leaves (§12). Every concrete HTML node is a Makiri::HTML::*
+  # class under the matching abstract base (so is_a?(Makiri::Element) etc. holds),
+  # carrying the lxb_dom-backed reader/query methods via the included
+  # Makiri::HTML::Node module. XML nodes never inherit these. The classes
+  # themselves are defined in C (ext/makiri/glue/ruby_html*.c); the per-class Ruby
+  # additions live in this namespace's files (html/node_methods.rb, html/document.rb).
+  module HTML
+  end
+end

data/lib/makiri/node.rb CHANGED Viewed

@@ -5,8 +5,29 @@ module Makiri
   # The bulk of the API lives in the C extension; this file defines the
   # Ruby-only conveniences.
   class Node
+    # Order by document (pre-order) position via the native #<=>, so nodes can
+    # be sorted; #<=> is nil (incomparable) across documents or for attributes.
+    include Comparable
+    # A Node is Enumerable over its child nodes (#each yields each child), so
+    # node.map / node.select / node.find / node.to_a, etc. work - like Nokogiri.
+    # (#to_h is unaffected: Node defines its own, returning the attribute hash.)
+    include Enumerable
     # Identity is by wrapped node pointer; defined in C.
+    # Yield each child node in document order. Iterates a snapshot of the
+    # children (taken when called), so the block may safely move or remove the
+    # current node. Returns an Enumerator when no block is given.
+    # @yieldparam child [Makiri::Node]
+    # @return [self, Enumerator]
+    def each(&block)
+      return enum_for(:each) { children.length } unless block_given?
+      children.each(&block)
+      self
+    end
     # @return [Boolean]
     def element?
       is_a?(Element)
@@ -22,9 +43,14 @@ module Makiri
       is_a?(Comment)
     end
+    # @return [Boolean]
+    def cdata?
+      is_a?(CDATASection)
+    end
     # @return [Boolean]
     def attribute?
-      is_a?(Attribute)
+      is_a?(Attr)
     end
     # @return [Boolean]
@@ -44,19 +70,16 @@ module Makiri
     # @return [Boolean] true for a blank/whitespace-only text or CDATA node.
     def blank?
-      (text? || is_a?(CData)) && content.strip.empty?
+      (text? || cdata?) && content.strip.empty?
     end
     # --- Nokogiri-compatible aliases over the core API ---
-    # Attribute value by name (alias for {#[]}). Use {#attribute} for the node.
-    alias_method :attr, :[]
-    alias_method :get_attribute, :[]
-    alias_method :has_attribute?, :key?
-    alias_method :remove_attribute, :delete
-    alias_method :node_name, :name
-    alias_method :node_name=, :name=
-    alias_method :type, :node_type
+    #
+    # Aliases of the representation-specific reader methods (#[], #name, ...) live
+    # with those methods on the per-kind node behaviour (Makiri::HTML::Node), not
+    # here, since alias_method resolves its target at definition time and the
+    # readers are defined on the leaves' included module. These two alias
+    # representation-independent predicates defined just above, so they stay.
     alias_method :elem?, :element?
     alias_method :fragment?, :document_fragment?
@@ -65,8 +88,8 @@ module Makiri
       self[name] = value
     end
-    # The Attribute node named +name+, or nil (cf. {#[]}, which returns the value).
-    # @return [Makiri::Attribute, nil]
+    # The Attr node named +name+, or nil (cf. {#[]}, which returns the value).
+    # @return [Makiri::Attr, nil]
     def attribute(name)
       attributes[name.to_s]
     end
@@ -122,8 +145,8 @@ module Makiri
       document.root
     end
-    # Attributes as a name => Attribute Hash (empty for non-elements).
-    # @return [Hash{String => Makiri::Attribute}]
+    # Attributes as a name => Attr Hash (empty for non-elements).
+    # @return [Hash{String => Makiri::Attr}]
     def attributes
       attribute_nodes.each_with_object({}) { |attr, h| h[attr.name] = attr }
     end
@@ -172,6 +195,26 @@ module Makiri
       "#<#{self.class.name}>"
     end
+    # An independent copy of this node, detached from any parent and owned by the
+    # same document (like Nokogiri's Node#dup). Deep by default; +level+ 0 makes
+    # a shallow copy (matching Nokogiri's level argument). The native allocator
+    # is undef'd to keep wrappers memory-safe, so #dup/#clone delegate to
+    # {#clone_node} rather than Ruby's default allocate-and-copy (which would
+    # otherwise raise "allocator undefined").
+    def dup(level = 1)
+      clone_node(level != 0)
+    end
+    # Like {#dup}, always a deep copy, and honouring Ruby's +freeze:+ keyword:
+    # +true+ returns a frozen copy, +false+ an unfrozen one, the default (+nil+)
+    # copies the receiver's frozen state. A frozen node is genuinely immutable -
+    # its mutators raise +FrozenError+ (see Makiri's mutation methods).
+    def clone(freeze: nil)
+      copy = clone_node(true)
+      copy.freeze if freeze || (freeze.nil? && frozen?)
+      copy
+    end
     private
     # Heuristic used by {#search}: does +path+ look like an XPath location path

data/lib/makiri/node_set.rb CHANGED Viewed

@@ -98,6 +98,14 @@ module Makiri
     end
     alias unlink remove
+    # Like {#dup} (a new set over the same nodes), honouring Ruby's +freeze:+
+    # keyword. (#dup is the native copy.)
+    def clone(freeze: nil)
+      copy = dup
+      copy.freeze if freeze || (freeze.nil? && frozen?)
+      copy
+    end
     def inspect
       "#<#{self.class.name} length=#{length}>"
     end

data/lib/makiri/processing_instruction.rb CHANGED Viewed

@@ -4,5 +4,17 @@ module Makiri
   # An XML/HTML processing-instruction node. Rare in HTML5 (the parser usually
   # treats "<?...>" as a bogus comment), present mainly for completeness.
   class ProcessingInstruction < Node
+    # Create a detached processing instruction owned by +document+ (Nokogiri-style,
+    # document first). Delegates to {Document#create_processing_instruction}.
+    #
+    # @param document [Makiri::Document]
+    # @param target [String]
+    # @param content [String]
+    # @return [Makiri::ProcessingInstruction]
+    def self.new(document, target, content)
+      raise TypeError, "expected a Makiri::Document" unless document.is_a?(Makiri::Document)
+      document.create_processing_instruction(target, content)
+    end
   end
 end

data/lib/makiri/text.rb CHANGED Viewed

@@ -10,6 +10,8 @@ module Makiri
     # @param document [Makiri::Document]
     # @return [Makiri::Text]
     def self.new(content, document)
+      raise TypeError, "expected a Makiri::Document" unless document.is_a?(Makiri::Document)
       document.create_text_node(content)
     end
   end

data/lib/makiri/version.rb CHANGED Viewed

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 module Makiri
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

data/lib/makiri/xml/document.rb ADDED Viewed

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+module Makiri
+  module XML
+    # XML-specific document conveniences. The XML node leaves and the document
+    # itself are defined in C (ext/makiri/glue/ruby_xml*.c); construction sugar
+    # that is pure composition over the public surface lives here, not on the
+    # abstract Makiri::Document (which carries no construction).
+    class Document
+      # Set (or replace) the document's root element: with an existing root it
+      # replaces that root, otherwise it appends one (subject to the single-root
+      # rule). Pure composition over {Node#replace} / {Node#add_child};
+      # Nokogiri-compatible. XML only - an HTML5 document has a fixed
+      # html/head/body structure, so a free-form root is not meaningful there.
+      #
+      # @param node [Makiri::XML::Element]
+      # @return [Makiri::XML::Element] the node
+      def root=(node)
+        r = root
+        r ? r.replace(node) : add_child(node)
+      end
+    end
+  end
+end

data/lib/makiri/xml/node_methods.rb ADDED Viewed

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+module Makiri
+  module XML
+    # Ruby additions over the C-defined XML node readers, mirroring
+    # Makiri::HTML::NodeMethods so the XML node surface matches the HTML one for
+    # the methods consumers (e.g. Dommy) rely on. Each is guarded with
+    # `method_defined?` so a future native implementation on this module takes
+    # precedence rather than being shadowed.
+    module NodeMethods
+      # Element ancestors, nearest first, excluding self (element nodes only) —
+      # matching Makiri::HTML's #ancestors.
+      unless method_defined?(:ancestors)
+        def ancestors
+          out = []
+          node = parent
+          while node
+            out << node if node.node_type == 1
+            node = node.respond_to?(:parent) ? node.parent : nil
+          end
+          out
+        end
+      end
+      # Whether an attribute with the given qualified name is present
+      # (case-sensitive, per XML).
+      unless method_defined?(:key?)
+        def key?(name)
+          wanted = name.to_s
+          attribute_nodes.any? { |attr| attr.name == wanted }
+        end
+      end
+      alias_method :has_attribute?, :key? unless method_defined?(:has_attribute?)
+    end
+  end
+end

data/lib/makiri/xml.rb ADDED Viewed

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+module Makiri
+  # XML-specific node leaves and document conveniences (§12), mirroring
+  # Makiri::HTML. The XML nodes and the document are defined in C
+  # (ext/makiri/glue/ruby_xml*.c); the per-class Ruby additions live in this
+  # namespace's files (xml/document.rb).
+  module XML
+  end
+end

data/lib/makiri/xpath_context.rb CHANGED Viewed

@@ -16,7 +16,7 @@ module Makiri
   class XPathContext
     # +#evaluate+ is defined in C. It evaluates under the GVL (XPath never
     # releases it), so concurrent +evaluate+ / +register_*+ / +node=+ on the
-    # same context — and any tree mutation of the document being queried — are
+    # same context - and any tree mutation of the document being queried - are
     # serialised by the GVL and cannot corrupt memory.
     # Nokogiri-compatible name for {#register_namespace}.

data/lib/makiri.rb CHANGED Viewed

@@ -15,11 +15,17 @@ end
 require_relative "makiri/node"
 require_relative "makiri/document"
+require_relative "makiri/html"
+require_relative "makiri/html/node_methods"
+require_relative "makiri/html/document"
+require_relative "makiri/xml"
+require_relative "makiri/xml/node_methods"
+require_relative "makiri/xml/document"
 require_relative "makiri/element"
-require_relative "makiri/attribute"
+require_relative "makiri/attr"
 require_relative "makiri/text"
 require_relative "makiri/comment"
-require_relative "makiri/cdata"
+require_relative "makiri/cdata_section"
 require_relative "makiri/processing_instruction"
 require_relative "makiri/document_type"
 require_relative "makiri/document_fragment"
@@ -27,6 +33,7 @@ require_relative "makiri/node_set"
 require_relative "makiri/xpath_context"
 require_relative "makiri/xpath"
 require_relative "makiri/css"
+require_relative "makiri/compat_aliases"
 module Makiri
   # Base exception class for Makiri-specific errors.
@@ -35,13 +42,24 @@ module Makiri
   # Convenience constructor mirroring Nokogiri.
   #
   # @param source [String] HTML source (UTF-8).
-  # @return [Makiri::Document]
+  # @return [Makiri::HTML::Document]
   def self.HTML(source) # rubocop:disable Naming/MethodName
-    Document.parse(source)
+    HTML::Document.parse(source)
   end
   # Alias for {.HTML}.
   def self.parse(source)
-    Document.parse(source)
+    HTML::Document.parse(source)
+  end
+  # Convenience XML constructor mirroring Nokogiri::XML(source). A method named
+  # XML on the Makiri module, coexisting with the Makiri::XML constant (the
+  # module), as Nokogiri::XML does. Delegates to {Makiri::XML::Document.parse},
+  # exactly as {.HTML} delegates to {Makiri::HTML::Document.parse}.
+  #
+  # @param source [String, #read] XML source (its String encoding is honoured).
+  # @return [Makiri::XML::Document]
+  def self.XML(source, **opts) # rubocop:disable Naming/MethodName
+    XML::Document.parse(source, **opts)
   end
 end