dommy 0.7.0 → 0.8.0

data/lib/dommy/text_codec.rb

@@ -10,17 +10,20 @@ module Dommy
       "utf-8"
     end
 
-    # encode(string) → Array<Integer> (bytes).
-    # Browsers return a Uint8Array; Dommy returns the equivalent Ruby
-    # byte array since there is no typed-array layer.
+    # encode(string) → Uint8Array (UTF-8 bytes). Lone surrogates in the input
+    # have already been replaced with U+FFFD when the JS string crossed into Ruby
+    # (Ruby strings can't hold them), matching the spec's USVString conversion.
     def encode(input = "")
-      input.to_s.encode(Encoding::UTF_8).bytes
+      str = input.equal?(Bridge::UNDEFINED) ? "" : input.to_s
+      Bridge::Bytes.new(str.encode(Encoding::UTF_8, invalid: :replace, undef: :replace).bytes)
     end
 
     def __js_get__(key)
       key == "encoding" ? encoding : nil
     end
 
+    include Bridge::Methods
+    js_methods %w[encode]
     def __js_call__(method, args)
       case method
       when "encode"
@@ -34,35 +37,50 @@ module Dommy
   #
   # Spec: https://encoding.spec.whatwg.org/#textdecoder
   class TextDecoder
-    def initialize(label = "utf-8", _options = nil)
+    def initialize(label = "utf-8", options = nil)
+      label = "utf-8" if label.nil? || label.equal?(Bridge::UNDEFINED)
       @encoding = normalize_encoding(label.to_s)
+      opts = options.is_a?(Hash) ? options : {}
+      @fatal = truthy?(opts["fatal"] || opts[:fatal])
+      @ignore_bom = truthy?(opts["ignoreBOM"] || opts[:ignoreBOM])
     end
 
-    def encoding
-      @encoding
-    end
+    attr_reader :encoding
+
+    def fatal? = @fatal
+    def ignore_bom? = @ignore_bom
 
-    # decode(bytes) → String. Accepts Array<Integer> (byte values),
-    # a binary String, or anything responding to to_a/bytes.
-    def decode(input = nil, _options = nil)
-      return "" if input.nil?
+    # decode(bytes, {stream}) → String. Accepts a Bytes buffer (JS ArrayBuffer /
+    # TypedArray), an Array<Integer>, or a binary String. With `fatal: true` an
+    # invalid sequence throws a TypeError; otherwise it is replaced with U+FFFD.
+    # A leading BOM is stripped unless `ignoreBOM` was set.
+    def decode(input = nil, options = nil)
+      stream = options.is_a?(Hash) && truthy?(options["stream"] || options[:stream])
+      bytes = extract_bytes(input)
 
-      bytes = case input
-      when String
-        input.b
-      when Array
-        input.pack("C*")
+      if @encoding == "utf-8"
+        decode_utf8(bytes, stream)
       else
-        input.respond_to?(:to_a) ? input.to_a.pack("C*") : input.to_s
-      end
+        # Non-UTF-8 (utf-16le/be, iso-8859-1): no streaming/exact-FFFD semantics,
+        # best-effort via Ruby's transcoder.
+        bytes = strip_bom(bytes) unless @ignore_bom
+        raw = bytes.force_encoding(ruby_encoding)
+        raise Bridge::TypeError, "decode failed" if @fatal && !raw.valid_encoding?
 
-      bytes.force_encoding(ruby_encoding).encode(Encoding::UTF_8, invalid: :replace, undef: :replace)
+        raw.encode(Encoding::UTF_8, invalid: :replace, undef: :replace)
+      end
     end
 
     def __js_get__(key)
-      key == "encoding" ? encoding : nil
+      case key
+      when "encoding" then @encoding
+      when "fatal" then @fatal
+      when "ignoreBOM" then @ignore_bom
+      end
     end
 
+    include Bridge::Methods
+    js_methods %w[decode]
     def __js_call__(method, args)
       case method
       when "decode"
@@ -72,6 +90,141 @@ module Dommy
 
     private
 
+    def extract_bytes(input)
+      return "".b if input.nil? || input.equal?(Bridge::UNDEFINED)
+
+      case input
+      when Bridge::Bytes then input.pack_bytes
+      when String then input.b
+      when Array then input.pack("C*")
+      else input.respond_to?(:to_a) ? input.to_a.pack("C*") : input.to_s.b
+      end
+    end
+
+    # WHATWG "UTF-8 decoder" — a stateful machine so streaming chunks, exact
+    # U+FFFD placement, and end-of-queue flushing match the spec (Ruby's
+    # transcoder replaces per-byte, which is wrong at sequence boundaries).
+    # State persists on the decoder across `{stream: true}` calls.
+    def decode_utf8(bytes, stream)
+      @u8_needed ||= 0
+      @u8_seen ||= 0
+      @u8_cp ||= 0
+      @u8_lower ||= 0x80
+      @u8_upper ||= 0xBF
+
+      out = []
+      queue = bytes.bytes
+      @u8_started = true
+
+      until queue.empty?
+        byte = queue.shift
+        if @u8_needed.zero?
+          if byte <= 0x7F
+            out << byte
+          elsif byte.between?(0xC2, 0xDF)
+            @u8_needed = 1
+            @u8_cp = byte & 0x1F
+          elsif byte.between?(0xE0, 0xEF)
+            @u8_lower = 0xA0 if byte == 0xE0
+            @u8_upper = 0x9F if byte == 0xED
+            @u8_needed = 2
+            @u8_cp = byte & 0x0F
+          elsif byte.between?(0xF0, 0xF4)
+            @u8_lower = 0x90 if byte == 0xF0
+            @u8_upper = 0x8F if byte == 0xF4
+            @u8_needed = 3
+            @u8_cp = byte & 0x07
+          else
+            out << utf8_error
+          end
+          next
+        end
+
+        unless byte.between?(@u8_lower, @u8_upper)
+          # Invalid continuation: emit an error and REPROCESS this byte.
+          reset_utf8_state
+          out << utf8_error
+          queue.unshift(byte)
+          next
+        end
+
+        @u8_lower = 0x80
+        @u8_upper = 0xBF
+        @u8_cp = (@u8_cp << 6) | (byte & 0x3F)
+        @u8_seen += 1
+        next unless @u8_seen == @u8_needed
+
+        out << @u8_cp
+        reset_utf8_state
+      end
+
+      unless stream
+        if @u8_needed != 0
+          reset_utf8_state
+          out << utf8_error
+        end
+      end
+
+      # Strip a leading byte-order mark at the code-point level, not the byte
+      # level: a BOM split across streaming chunks (EF BB in one decode() call,
+      # BF in the next) only surfaces as a single U+FEFF once the full sequence
+      # decodes, which a byte-prefix check would miss. The "BOM seen" flag
+      # persists across `{stream: true}` calls and is reset on flush.
+      unless @ignore_bom || @u8_bom_seen
+        if out[0] == 0xFEFF
+          out.shift
+          @u8_bom_seen = true
+        elsif !out.empty?
+          @u8_bom_seen = true
+        end
+      end
+
+      unless stream
+        @u8_started = false
+        @u8_bom_seen = false
+      end
+
+      out.pack("U*")
+    end
+
+    # In fatal mode an error throws a TypeError; otherwise it is the U+FFFD
+    # replacement code point.
+    def utf8_error
+      raise Bridge::TypeError, "The encoded data was not valid for encoding utf-8" if @fatal
+
+      0xFFFD
+    end
+
+    def reset_utf8_state
+      @u8_needed = 0
+      @u8_seen = 0
+      @u8_cp = 0
+      @u8_lower = 0x80
+      @u8_upper = 0xBF
+    end
+
+    # JS ToBoolean for an option-bag value (false/nil/undefined/0/"" are falsy).
+    def truthy?(value)
+      return false if value.nil? || value == false || value == 0 || value == ""
+      return false if defined?(Bridge::UNDEFINED) && value.equal?(Bridge::UNDEFINED)
+
+      true
+    end
+
+    # Remove a leading byte-order mark matching this decoder's encoding.
+    def strip_bom(bytes)
+      case @encoding
+      when "utf-8"
+        bytes.start_with?("\xEF\xBB\xBF".b) ? bytes.byteslice(3..) : bytes
+      when "utf-16le"
+        bytes.start_with?("\xFF\xFE".b) ? bytes.byteslice(2..) : bytes
+      when "utf-16be"
+        bytes.start_with?("\xFE\xFF".b) ? bytes.byteslice(2..) : bytes
+      else
+        bytes
+      end
+    end
+
     def normalize_encoding(label)
       l = label.downcase.strip
       case l

data/lib/dommy/tree_walker.rb

@@ -21,23 +21,17 @@ module Dommy
 
     # Map a wrapped Dommy node to its NodeFilter bitmask. Returns 0
     # for unknown node types (effectively "doesn't pass any filter").
+    # whatToShow bit for a node: WHATWG defines it as `1 << (nodeType - 1)`,
+    # which covers every node type (Element, Text, CDATASection, PI, Comment,
+    # Document, DocumentType, DocumentFragment, Attribute) uniformly.
     def self.bitmask_for(node)
-      case node
-      when Element
-        SHOW_ELEMENT
-      when TextNode
-        SHOW_TEXT
-      when CommentNode
-        SHOW_COMMENT
-      when Fragment
-        SHOW_DOCUMENT_FRAGMENT
-      when Document
-        SHOW_DOCUMENT
-      when DocumentType
-        SHOW_DOCUMENT_TYPE
-      else
-        0
-      end
+      nt =
+        if node.respond_to?(:node_type) then node.node_type
+        elsif node.respond_to?(:__js_get__) then node.__js_get__("nodeType")
+        end
+      return 0 unless nt.is_a?(Integer) && nt >= 1
+
+      1 << (nt - 1)
     end
   end
 
@@ -58,15 +52,40 @@ module Dommy
     end
 
     def invoke_filter(node)
-      return NodeFilter::FILTER_ACCEPT if @filter.nil?
+      return NodeFilter::FILTER_ACCEPT if @filter.nil? || (defined?(Bridge::UNDEFINED) && @filter.equal?(Bridge::UNDEFINED))
+
+      cb = filter_callback
+      # A non-null filter with no callable acceptNode is a TypeError when invoked.
+      raise Bridge::TypeError, "NodeFilter is not callable" unless cb
 
-      if @filter.respond_to?(:accept_node)
-        @filter.accept_node(node)
-      elsif @filter.respond_to?(:call)
-        @filter.call(node)
+      result = if cb.respond_to?(:__js_call__)
+        cb.__js_call__("call", [node])
       else
-        NodeFilter::FILTER_ACCEPT
+        cb.call(node)
       end
+      # WebIDL coerces the filter return (an `unsigned short`): booleans and
+      # null become 0/1, everything else ToInteger.
+      return 1 if result == true
+      return 0 if result == false || result.nil?
+
+      result.to_i
+    end
+
+    # The actual filter callback: a function filter is called directly; an object
+    # filter's `acceptNode` is used (WebIDL callback interface).
+    def filter_callback
+      return @filter if callable?(@filter)
+
+      accept_node =
+        if @filter.respond_to?(:accept_node) then @filter.method(:accept_node)
+        elsif @filter.is_a?(Hash) then (@filter["acceptNode"] || @filter[:acceptNode])
+        elsif @filter.respond_to?(:__js_get__) then @filter.__js_get__("acceptNode")
+        end
+      callable?(accept_node) ? accept_node : nil
+    end
+
+    def callable?(value)
+      value && (value.respond_to?(:__js_call__) || value.respond_to?(:call))
     end
   end
 
@@ -90,32 +109,55 @@ module Dommy
     end
 
     def next_node
-      node = first_descendant_or_following(@current_node)
-      while node
-        verdict = accept(node)
-        if verdict == NodeFilter::FILTER_ACCEPT
-          @current_node = node
-          return node
+      node = @current_node
+      result = NodeFilter::FILTER_ACCEPT
+      loop do
+        while result != NodeFilter::FILTER_REJECT && (child = first_wrapped_child(node))
+          node = child
+          result = accept(node)
+          return @current_node = node if result == NodeFilter::FILTER_ACCEPT
         end
 
-        node = (verdict == NodeFilter::FILTER_REJECT) ? following_skip_subtree(node) : first_descendant_or_following(
-          node
-        )
-      end
+        sibling = nil
+        temp = node
+        while temp
+          return nil if temp == @root
+
+          sibling = next_sibling_wrapped(temp)
+          if sibling
+            node = sibling
+            break
+          end
+          temp = wrapped_parent(temp)
+        end
+        return nil unless sibling
 
-      nil
+        result = accept(node)
+        return @current_node = node if result == NodeFilter::FILTER_ACCEPT
+      end
     end
 
     def previous_node
-      node = preceding(@current_node)
-      while node && node != @root
-        verdict = accept(node)
-        if verdict == NodeFilter::FILTER_ACCEPT
-          @current_node = node
-          return node
+      node = @current_node
+      while node != @root
+        sibling = previous_sibling_wrapped(node)
+        while sibling
+          node = sibling
+          result = accept(node)
+          while result != NodeFilter::FILTER_REJECT && (child = last_wrapped_child(node))
+            node = child
+            result = accept(node)
+          end
+          return @current_node = node if result == NodeFilter::FILTER_ACCEPT
+
+          sibling = previous_sibling_wrapped(node)
         end
 
-        node = preceding(node)
+        parent = wrapped_parent(node)
+        return nil if node == @root || parent.nil?
+
+        node = parent
+        return @current_node = node if accept(node) == NodeFilter::FILTER_ACCEPT
       end
 
       nil
@@ -133,21 +175,19 @@ module Dommy
     end
 
     def first_child
-      first = first_wrapped_child(@current_node)
-      walk_siblings(first, :next_sibling_wrapped)
+      traverse_children(:first_wrapped_child, :next_sibling_wrapped)
     end
 
     def last_child
-      last = last_wrapped_child(@current_node)
-      walk_siblings(last, :previous_sibling_wrapped)
+      traverse_children(:last_wrapped_child, :previous_sibling_wrapped)
     end
 
     def next_sibling
-      walk_siblings(next_sibling_wrapped(@current_node), :next_sibling_wrapped)
+      traverse_siblings(:next_sibling_wrapped, :first_wrapped_child)
     end
 
     def previous_sibling
-      walk_siblings(previous_sibling_wrapped(@current_node), :previous_sibling_wrapped)
+      traverse_siblings(:previous_sibling_wrapped, :last_wrapped_child)
     end
 
     def __js_get__(key)
@@ -164,10 +204,17 @@ module Dommy
     end
 
     def __js_set__(key, value)
-      @current_node = value if key == "currentNode"
+      return Bridge::UNHANDLED unless key == "currentNode"
+
+      # currentNode is a non-null `Node`; non-Node values are a TypeError.
+      raise Bridge::TypeError, "currentNode must be a Node" unless value.is_a?(Dommy::Node)
+
+      @current_node = value
       nil
     end
 
+    include Bridge::Methods
+    js_methods %w[nextNode previousNode parentNode firstChild lastChild nextSibling previousSibling]
     def __js_call__(method, _args)
       case method
       when "nextNode"
@@ -189,18 +236,62 @@ module Dommy
 
     private
 
-    def walk_siblings(start, direction)
-      node = start
+    # WHATWG "traverse children": a SKIP node is transparent (descend into its
+    # children); a REJECT node is opaque (skip it and its subtree, advance to the
+    # next sibling, climbing toward currentNode as needed).
+    def traverse_children(descend, sibling_dir)
+      node = send(descend, @current_node)
       while node
         v = accept(node)
         return @current_node = node if v == NodeFilter::FILTER_ACCEPT
 
-        node = (v == NodeFilter::FILTER_REJECT) ? nil : send(direction, node)
+        if v == NodeFilter::FILTER_SKIP
+          child = send(descend, node)
+          if child
+            node = child
+            next
+          end
+        end
+
+        loop do
+          sib = send(sibling_dir, node)
+          if sib
+            node = sib
+            break
+          end
+          parent = wrapped_parent(node)
+          return nil if parent.nil? || parent == @root || parent == @current_node
+
+          node = parent
+        end
       end
 
       nil
     end
 
+    # WHATWG "traverse siblings": walk siblings of currentNode; a SKIP sibling's
+    # children are searched (descend), a REJECT sibling's subtree is skipped.
+    def traverse_siblings(sibling_dir, child_dir)
+      node = @current_node
+      return nil if node == @root
+
+      loop do
+        sib = send(sibling_dir, node)
+        while sib
+          node = sib
+          v = accept(node)
+          return @current_node = node if v == NodeFilter::FILTER_ACCEPT
+
+          sib = send(child_dir, node)
+          sib = send(sibling_dir, node) if v == NodeFilter::FILTER_REJECT || sib.nil?
+        end
+
+        node = wrapped_parent(node)
+        return nil if node.nil? || node == @root
+        return nil if accept(node) == NodeFilter::FILTER_ACCEPT
+      end
+    end
+
     def first_descendant_or_following(node)
       child = first_wrapped_child(node)
       return child if child
@@ -253,23 +344,46 @@ module Dommy
       doc.wrap_node(parent_nk)
     end
 
+    # The Nokogiri node backing a wrapper — an element's `__dommy_backend_node__`
+    # or, for a Document (which isn't a wrapped node), its `nokogiri_doc`. Lets a
+    # walker rooted at the document descend into its children.
+    def backend_node_of(node)
+      if node.respond_to?(:__dommy_backend_node__)
+        node.__dommy_backend_node__
+      elsif node.respond_to?(:nokogiri_doc)
+        node.nokogiri_doc
+      end
+    end
+
+    # Wrap the first Nokogiri node in `list` that has a wrapper, skipping ones
+    # that don't (e.g. the DTD, which Dommy doesn't model as a child node).
+    def first_wrappable(list, ctx)
+      list.each do |nk|
+        w = document_for(ctx).wrap_node(nk)
+        return w if w
+      end
+      nil
+    end
+
     def first_wrapped_child(node)
-      child_nk = node.respond_to?(:__dommy_backend_node__) ? node.__dommy_backend_node__.children.first : nil
-      child_nk && document_for(node).wrap_node(child_nk)
+      bn = backend_node_of(node)
+      bn ? first_wrappable(bn.children, node) : nil
     end
 
     def last_wrapped_child(node)
-      child_nk = node.respond_to?(:__dommy_backend_node__) ? node.__dommy_backend_node__.children.last : nil
-      child_nk && document_for(node).wrap_node(child_nk)
+      bn = backend_node_of(node)
+      bn ? first_wrappable(bn.children.reverse, node) : nil
     end
 
     def next_sibling_wrapped(node)
       n = node.respond_to?(:__dommy_backend_node__) ? node.__dommy_backend_node__.next : nil
+      n = n.next while n && document_for(node).wrap_node(n).nil?
       n && document_for(node).wrap_node(n)
     end
 
     def previous_sibling_wrapped(node)
       n = node.respond_to?(:__dommy_backend_node__) ? node.__dommy_backend_node__.previous : nil
+      n = n.previous while n && document_for(node).wrap_node(n).nil?
       n && document_for(node).wrap_node(n)
     end
 
@@ -294,35 +408,45 @@ module Dommy
       @pointer_before_reference = true
     end
 
+    # WHATWG "traverse" (direction=next). referenceNode / pointerBeforeReferenceNode
+    # are committed only when a node is accepted; if no node matches we return null
+    # and leave the iterator's position untouched.
     def next_node
+      node = @reference_node
+      before = @pointer_before_reference
       loop do
-        node = if @pointer_before_reference
-          @reference_node
+        if before
+          before = false
         else
-          next_in_document_order(@reference_node)
+          node = next_in_document_order(node)
+          return nil unless node
         end
 
-        return nil unless node
+        next unless accept(node) == NodeFilter::FILTER_ACCEPT
 
         @reference_node = node
-        @pointer_before_reference = false
-        return node if accept(node) == NodeFilter::FILTER_ACCEPT
+        @pointer_before_reference = before
+        return node
       end
     end
 
+    # WHATWG "traverse" (direction=previous).
     def previous_node
+      node = @reference_node
+      before = @pointer_before_reference
       loop do
-        node = if @pointer_before_reference
-          previous_in_document_order(@reference_node)
+        if before
+          node = previous_in_document_order(node)
+          return nil unless node
         else
-          @reference_node
+          before = true
         end
 
-        return nil unless node
+        next unless accept(node) == NodeFilter::FILTER_ACCEPT
 
         @reference_node = node
-        @pointer_before_reference = true
-        return node if accept(node) == NodeFilter::FILTER_ACCEPT
+        @pointer_before_reference = before
+        return node
       end
     end
 
@@ -330,6 +454,30 @@ module Dommy
       nil
     end
 
+    # WHATWG "NodeIterator pre-removing steps". `removed` is the wrapped node
+    # about to be detached (still attached when this runs).
+    def pre_remove(removed)
+      # Terminate unless `removed` is in this iterator's collection and an
+      # inclusive ancestor of the reference node: skip if it is an inclusive
+      # ancestor of root (never in the collection) or not one of referenceNode.
+      return if inclusive_ancestor?(removed, @root)
+      return unless inclusive_ancestor?(removed, @reference_node)
+
+      unless @pointer_before_reference
+        @reference_node = tree_preceding(removed)
+        return
+      end
+
+      following = tree_next_descendants(removed)
+      if following
+        @reference_node = following
+        return
+      end
+
+      @reference_node = tree_preceding(removed)
+      @pointer_before_reference = false
+    end
+
     def __js_get__(key)
       case key
       when "root"
@@ -345,6 +493,8 @@ module Dommy
       end
     end
 
+    include Bridge::Methods
+    js_methods %w[nextNode previousNode detach]
     def __js_call__(method, _args)
       case method
       when "nextNode"
@@ -421,5 +571,44 @@ module Dommy
     def document_for(node)
       node.instance_variable_get(:@document) || @root.instance_variable_get(:@document) || @root
     end
+
+    def same_node?(node_a, node_b)
+      return false unless node_a && node_b
+      return true if node_a.equal?(node_b)
+
+      node_a.respond_to?(:__dommy_backend_node__) && node_b.respond_to?(:__dommy_backend_node__) &&
+        node_a.__dommy_backend_node__.equal?(node_b.__dommy_backend_node__)
+    end
+
+    def inclusive_ancestor?(ancestor, descendant)
+      current = descendant
+      while current
+        return true if same_node?(current, ancestor)
+
+        current = parent_node_of(current)
+      end
+      false
+    end
+
+    # The last node preceding `node` in tree order (common.js `previousNode`).
+    def tree_preceding(node)
+      sib = previous_sibling_node(node)
+      if sib
+        node = sib
+        while (last = last_child_node(node))
+          node = last
+        end
+        return node
+      end
+
+      parent_node_of(node)
+    end
+
+    # The first node following `node` and all its descendants in tree order
+    # (common.js `nextNodeDescendants`).
+    def tree_next_descendants(node)
+      node = parent_node_of(node) while node && next_sibling_node(node).nil?
+      node && next_sibling_node(node)
+    end
   end
 end