leptris 1.9.222.0 → 1.9.222.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 403ad2f7e9b542b03e8f770c1b070e0e972ac0b4aca5ae16e5ed8f675b7599e4
-  data.tar.gz: 5e5c49bb4ffdda23e1466b653346e6c20de604212a2941c97a9fa2c6b2297f83
+  metadata.gz: bded827a8ed4a8dcac8efcda8a391e79b497c122c57b65115027025b406c027b
+  data.tar.gz: 7171d06a07b227717f12de2a2bcccaabefce5067fb0d49d6632f1010b65fdb31
 SHA512:
-  metadata.gz: 751de9f301ea9157169b546b3d81c8c65942e6c13fd8516bbd4e7ec6e940877146e634bccb92ab1b043c63f0b77bca5c3ea7cb83d81d539228a38cba6eaba072
-  data.tar.gz: e38a36cfdcf7d4d52d007389dbc6ca5ab4e5f84f8794af81667837005a5928a776dc532b86b50dc8dc32644e8d0cbde979f9edfaa89695564e91e33dd5320d02
+  metadata.gz: 1055292d2190857575b0858cc61a2f1db481324c6ea56097894131a19bf43b360b72db03de87c908e3e071c6f68d71e4a973134580d40619f82ed772b7f106a6
+  data.tar.gz: 402c643195961c7159f6af522b8cac0f5366ca1a44ea94490ff69482b6311ab912fbae23044997af721544a0b0810fb37d8a6f2e9048c24e58086295d3b13965

data/ext/leptris/native/native.c

@@ -2150,6 +2150,34 @@ static VALUE nf_plan_structs_typed_p(VALUE self)
     return Qtrue;
 }
 
+/* ---- Bulk attribute rows (leptris-ruby#278) ----------------------
+ * One C crossing per element: walks the attribute chain and
+ * returns a flat [name, value, address, ...] array. Names
+ * interned (they repeat), values fresh UTF-8 strings, addresses
+ * as Integers for Attr c_handle reconstruction. Identical data
+ * to the per-attribute FFI chain (first/next/get_name/get_value,
+ * 4 crossings each) — the win amplifies with attribute density
+ * (40-attr elements: ~7x on the listing). */
+static VALUE nf_attribute_rows(VALUE self, VALUE document, VALUE addr)
+{
+    (void)self;
+    (void)document;
+    void *node = (void *)(uintptr_t)NUM2ULL(addr);
+    VALUE out = rb_ary_new();
+    if (f_node_type(node) != WS_NODE_ELEMENT) return out;
+
+    for (void *a = f_attr_first(node); a; a = f_attr_next(a)) {
+        const char *an = f_attr_name(a);
+        const char *av = f_attr_value(node, a);
+        rb_ary_push(out, an ? rb_enc_interned_str(an, strlen(an),
+                                                  rb_utf8_encoding())
+                            : Qnil);
+        rb_ary_push(out, av ? rb_utf8_str_new_cstr(av) : Qnil);
+        rb_ary_push(out, ULL2NUM((uintptr_t)a));
+    }
+    return out;
+}
+
 static VALUE nf_plan_structs(VALUE self, VALUE document, VALUE addr,
                              VALUE spec)
 {
@@ -2732,6 +2760,8 @@ LEPTRIS_INIT_EXPORT void Init_native(void)
                               nf_attribute_pairs, 2);
     rb_define_module_function(m_native, "plan_structs",
                               nf_plan_structs, 3);
+    rb_define_module_function(m_native, "attribute_rows",
+                              nf_attribute_rows, 2);
     rb_define_module_function(m_native, "plan_structs_typed?",
                               nf_plan_structs_typed_p, 0);
     rb_define_module_function(m_native, "doc_handle_attach",

data/lib/leptris/html.rb

@@ -10,9 +10,15 @@
 #   Leptris::HTML(html)          # the html4 lane (Nokogiri::HTML parity)
 #   Leptris::HTML5.parse(html)   # the WHATWG engine (html5lib zero reds)
 #   Leptris::HTML4.parse(html)   # explicit html4 lane
+#   Leptris::HTML5.create        # fresh document, <!DOCTYPE html> preset
 #
 # These are pure delegates — no parallel class hierarchy, no second
 # wrapper cache; identity and the whole XML surface carry over.
+# Construction flows through the same face as XML (create_element,
+# add_child, root=, set_doctype) — `create` presets the doctype so a
+# programmatically built document serializes with it; pair with
+# `to_xml(no_decl: true)` for declaration-free HTML output (void
+# elements serialize with the HTML5-legal trailing slash).
 module Leptris
   module HTML
     module_function
@@ -22,6 +28,37 @@ module Leptris
     def parse(html)
       Leptris::XML.parse_html(html, mode: :html4)
     end
+
+    # Fresh document with the HTML 4.01 Transitional doctype preset
+    # (Nokogiri::HTML::Builder's .doc carries the same). Pass
+    # +doctype: nil+ for a bare document.
+    def create(doctype: :transitional, skeleton: true)
+      create_document(doctype, skeleton: skeleton)
+    end
+
+    def create_document(doctype, skeleton: true)
+      doc = Leptris::XML::Document.create
+      case doctype
+      when :html5, true
+        doc.set_doctype("html")
+      when :transitional
+        doc.set_doctype(
+          "HTML",
+          public_id: "-//W3C//DTD HTML 4.01 Transitional//EN",
+          system_id: "http://www.w3.org/TR/html4/loose.dtd")
+      when nil, false then nil
+      else raise ArgumentError,
+        "doctype must be :html5, :transitional, nil, or false, got #{doctype.inspect}"
+      end
+      return doc unless skeleton
+      html = doc.create_element("html")
+      head = doc.create_element("head")
+      body = doc.create_element("body")
+      html.add_child(head)
+      html.add_child(body)
+      doc.root = html
+      doc
+    end
   end
 
   module HTML4
@@ -30,6 +67,10 @@ module Leptris
     def parse(html)
       Leptris::XML.parse_html(html, mode: :html4)
     end
+
+    def create(doctype: :transitional, skeleton: true)
+      Leptris::HTML.create_document(doctype, skeleton: skeleton)
+    end
   end
 
   module HTML5
@@ -41,5 +82,11 @@ module Leptris
     def parse(html)
       Leptris::XML.parse_html(html, mode: :whatwg)
     end
+
+    # Fresh document with the HTML5 doctype (`<!DOCTYPE html>`)
+    # preset; pass +doctype: nil+ for a bare document.
+    def create(doctype: :html5, skeleton: true)
+      Leptris::HTML.create_document(doctype, skeleton: skeleton)
+    end
   end
 end

data/lib/leptris/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Leptris
-  VERSION = "1.9.222.0"
+  VERSION = "1.9.222.2"
 end

data/lib/leptris/xml/document.rb

@@ -474,6 +474,16 @@ class Leptris::XML::Document
   alias_method :to_s, :to_xml
   alias_method :serialize, :to_xml
 
+  # HTML5 serialization (#309): void elements without a trailing
+  # slash (`<br>`), script/style content as raw text, text/attr
+  # entity escaping per HTML rules, the DOCTYPE emitted first.
+  # Walks the tree in Ruby — the engine-side serialization mode is
+  # the perf headroom this face gates on.
+  def to_html
+    raise Leptris::XML::UseAfterFreeError if @freed.state == :freed
+    Leptris::XML::HTMLSerialize.document(self)
+  end
+
   def save(path, **opts)
     opts_struct, _encoding_anchor = Leptris::XML::Serialization.build_options(
       indent: opts.fetch(:indent, 0),

data/lib/leptris/xml/element.rb

@@ -311,7 +311,11 @@ class Leptris::XML::Element < Leptris::XML::Node
 
   def attribute_nodes
     return @attribute_nodes if memo_hit?(@attribute_nodes_version)
-    result = each_attribute.to_a
+    result = if NATIVE_ATTR_ROWS && @c_address && @document
+               attribute_rows_native
+             else
+               each_attribute.to_a
+             end
     if @document
       @attribute_nodes = result
       @attribute_nodes_version = @document.version
@@ -319,6 +323,26 @@ class Leptris::XML::Element < Leptris::XML::Node
     result
   end
 
+  # One C crossing per element (leptris-ruby#278): the native face
+  # walks the attribute chain and returns flat [name, value,
+  # address] triples; the Attr value objects are minted from them
+  # with zero further engine crossings — identical objects to
+  # each_attribute. The win amplifies with attribute density
+  # (40-attr elements list ~7x faster than the chain).
+  def attribute_rows_native
+    ::Leptris::XML::Native.attribute_rows(@document, @c_address)
+      .each_slice(3)
+      .map do |name, value, handle|
+        ::Leptris::XML::Attr.new(name, value, self,
+                                 c_handle: ::FFI::Pointer.new(handle))
+      end
+  end
+
+  NATIVE_ATTR_ROWS =
+    defined?(::Leptris::XML::Native) &&
+    ::Leptris::XML::Native.respond_to?(:attribute_rows)
+  private_constant :NATIVE_ATTR_ROWS
+
   # The element's own namespace prefix (e.g. "foo" for <foo:child/>),
   # or nil when the element has none.
   def prefix
@@ -756,6 +780,13 @@ class Leptris::XML::Element < Leptris::XML::Node
       indent: indent, no_decl: no_decl, encoding: encoding)
   end
 
+  # HTML5 serialization of this element subtree (#309 — see
+  # Document#to_html for the semantics).
+  def to_html
+    ensure_alive!
+    Leptris::XML::HTMLSerialize.element(self)
+  end
+
   def canonicalize(version = Leptris::XML::FFI::C14N_1_0,
                    inclusive_namespaces = nil,
                    with_comments: false,

data/lib/leptris/xml/html_serialize.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+# The HTML5 tree serializer (#309): Ruby-level walk emitting
+# HTML serialization semantics the XML face can't express —
+#
+# - VOID elements (br, meta, img, …) emit without the trailing
+#   slash and without a closing tag (`<br>`, `<meta charset="utf-8">`)
+# - script/style content is RAW TEXT — emitted verbatim, never
+#   entity-escaped (`a > b` stays `a > b` inside `<style>`)
+# - childless non-void elements get explicit closing tags
+#   (`<div></div>`, never `<div/>`)
+# - text escapes &, <, > (and U+00A0 as &nbsp;); attributes escape
+#   &, ", <, >
+#
+# `Document#to_html` / `Element#to_html` are one-line delegates.
+# The walk is Ruby-level by design for now — the engine-side
+# serialization mode (raw-text + void handling in C) is the
+# perf headroom this face gates on.
+module Leptris::XML::HTMLSerialize
+  VOID = %w[
+    area base br col embed hr img input link meta param source
+    track wbr
+  ].freeze
+  RAW_TEXT = %w[script style].freeze
+
+  def self.document(doc)
+    out = +""
+    if (dt = doc.doctype)
+      out << "<!DOCTYPE" << " #{dt.name}"
+      out << " PUBLIC \"#{dt.public_id}\"" if dt.public_id
+      out << " \"#{dt.system_id}\"" if dt.system_id
+      out << ">"
+    end
+    doc.children.each { |child| node(child, out) }
+    out
+  end
+
+  def self.element(element)
+    out = +""
+    node(element, out)
+    out
+  end
+
+  def self.node(node, out)
+    case node
+    when Leptris::XML::Element then element_node(node, out)
+    when Leptris::XML::Comment then out << "<!--" << node.content.to_s << "-->"
+    when Leptris::XML::CDATA
+      # HTML5: CDATA sections in HTML serialize as bogus comments.
+      out << "<!--[CDATA[" << node.content.to_s << "]]-->"
+    when Leptris::XML::ProcessingInstruction
+      # HTML5: PIs serialize as bogus comments (?> is not a thing).
+      out << "<?" << node.target.to_s
+      out << " " << node.data.to_s unless node.data.to_s.empty?
+      out << ">"
+    when Leptris::XML::Text then text(node, out)
+    end
+  end
+
+  def self.element_node(el, out)
+    name = el.name
+    out << "<" << name
+    el.attributes.each do |attr_name, attr|
+      out << " " << attr_name << "=\"" << escape_attr(attr.value) << "\""
+    end
+    out << ">"
+    return if VOID.include?(name)
+
+    if RAW_TEXT.include?(name)
+      # Raw text: the element's text content verbatim — no entity
+      # escaping (CSS child selectors, JS comparisons survive).
+      el.children.each do |child|
+        out << child.content.to_s if child.is_a?(Leptris::XML::Text)
+      end
+    else
+      el.children.each { |child| node(child, out) }
+    end
+    out << "</" << name << ">"
+  end
+
+  def self.text(node, out)
+    parent_raw = node.parent && RAW_TEXT.include?(node.parent.name)
+    s = node.content.to_s
+    out << (parent_raw ? s : escape_text(s))
+  end
+
+  def self.escape_text(s)
+    s.gsub("&", "&amp;").gsub("<", "&lt;").gsub(">", "&gt;")
+     .gsub("\u00A0", "&nbsp;")
+  end
+
+  def self.escape_attr(s)
+    s.to_s.gsub("&", "&amp;").gsub("\"", "&quot;")
+          .gsub("<", "&lt;").gsub(">", "&gt;")
+          .gsub("\u00A0", "&nbsp;")
+  end
+end

data/lib/leptris/xml.rb

@@ -21,6 +21,7 @@ module Leptris
     autoload :CssToXPath, "leptris/xml/css_to_xpath"
     autoload :CStringArray, "leptris/xml/c_string_array"
     autoload :Serialization, "leptris/xml/serialization"
+    autoload :HTMLSerialize, "leptris/xml/html_serialize"
     autoload :SAX, "leptris/xml/sax"
     autoload :XPath, "leptris/xml/xpath"
     autoload :EvaluationContext, "leptris/xml/evaluation_context"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: leptris
 version: !ruby/object:Gem::Version
-  version: 1.9.222.0
+  version: 1.9.222.2
 platform: ruby
 authors:
 - Ribose Inc.
@@ -179,6 +179,7 @@ files:
 - lib/leptris/xml/entity_reference.rb
 - lib/leptris/xml/evaluation_context.rb
 - lib/leptris/xml/ffi.rb
+- lib/leptris/xml/html_serialize.rb
 - lib/leptris/xml/iteration_scope.rb
 - lib/leptris/xml/iterparse.rb
 - lib/leptris/xml/namespace.rb