dommy 0.5.0 → 0.7.0

data/lib/dommy/text_codec.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+module Dommy
+  # `TextEncoder` — encodes a String into UTF-8 bytes.
+  # Per spec, only "utf-8" encoding is supported.
+  #
+  # Spec: https://encoding.spec.whatwg.org/#textencoder
+  class TextEncoder
+    def encoding
+      "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.
+    def encode(input = "")
+      input.to_s.encode(Encoding::UTF_8).bytes
+    end
+
+    def __js_get__(key)
+      key == "encoding" ? encoding : nil
+    end
+
+    def __js_call__(method, args)
+      case method
+      when "encode"
+        encode(args[0])
+      end
+    end
+  end
+
+  # `TextDecoder` — decodes bytes into a String. Supports utf-8,
+  # utf-16, utf-16le, utf-16be, iso-8859-1 (best-effort).
+  #
+  # Spec: https://encoding.spec.whatwg.org/#textdecoder
+  class TextDecoder
+    def initialize(label = "utf-8", _options = nil)
+      @encoding = normalize_encoding(label.to_s)
+    end
+
+    def encoding
+      @encoding
+    end
+
+    # 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?
+
+      bytes = case input
+      when String
+        input.b
+      when Array
+        input.pack("C*")
+      else
+        input.respond_to?(:to_a) ? input.to_a.pack("C*") : input.to_s
+      end
+
+      bytes.force_encoding(ruby_encoding).encode(Encoding::UTF_8, invalid: :replace, undef: :replace)
+    end
+
+    def __js_get__(key)
+      key == "encoding" ? encoding : nil
+    end
+
+    def __js_call__(method, args)
+      case method
+      when "decode"
+        decode(args[0], args[1])
+      end
+    end
+
+    private
+
+    def normalize_encoding(label)
+      l = label.downcase.strip
+      case l
+      when "utf-8", "utf8"
+        "utf-8"
+      when "utf-16", "utf-16le"
+        "utf-16le"
+      when "utf-16be"
+        "utf-16be"
+      when "iso-8859-1", "latin1"
+        "iso-8859-1"
+      else
+        "utf-8"
+      end
+    end
+
+    def ruby_encoding
+      case @encoding
+      when "utf-8"
+        Encoding::UTF_8
+      when "utf-16le"
+        Encoding::UTF_16LE
+      when "utf-16be"
+        Encoding::UTF_16BE
+      when "iso-8859-1"
+        Encoding::ISO_8859_1
+      else
+        Encoding::UTF_8
+      end
+    end
+  end
+
+  # `TextEncoderStream` — Stream-shaped wrapper over `TextEncoder`.
+  # `write(string)` flushes UTF-8 bytes downstream.
+  class TextEncoderStream
+    attr_reader :readable, :writable
+
+    def initialize(window)
+      encoder = TextEncoder.new
+      @readable = ReadableStream.new(window)
+      controller = TransformStreamDefaultController.new(@readable)
+
+      @writable = WritableStream.new(
+        window,
+        {
+          "write" => proc { |chunk| controller.enqueue(encoder.encode(chunk)) },
+          "close" => proc { @readable.__internal_close__ },
+          "abort" => proc { |r| @readable.__internal_error__(r) }
+        }
+      )
+    end
+
+    def encoding
+      "utf-8"
+    end
+
+    def __js_get__(key)
+      case key
+      when "readable"
+        @readable
+      when "writable"
+        @writable
+      when "encoding"
+        encoding
+      end
+    end
+  end
+
+  # `TextDecoderStream` — Stream-shaped wrapper over `TextDecoder`.
+  # `write(bytes)` flushes decoded strings downstream.
+  class TextDecoderStream
+    attr_reader :readable, :writable, :encoding
+
+    def initialize(window, label = "utf-8", _options = nil)
+      decoder = TextDecoder.new(label)
+      @encoding = decoder.encoding
+      @readable = ReadableStream.new(window)
+      controller = TransformStreamDefaultController.new(@readable)
+
+      @writable = WritableStream.new(
+        window,
+        {
+          "write" => proc { |chunk| controller.enqueue(decoder.decode(chunk)) },
+          "close" => proc { @readable.__internal_close__ },
+          "abort" => proc { |r| @readable.__internal_error__(r) }
+        }
+      )
+    end
+
+    def __js_get__(key)
+      case key
+      when "readable"
+        @readable
+      when "writable"
+        @writable
+      when "encoding"
+        @encoding
+      end
+    end
+  end
+end

data/lib/dommy/tree_walker.rb

@@ -45,9 +45,11 @@ module Dommy
   # tree rooted at `root` and filter by `whatToShow` + an optional
   # filter callable (or object with `acceptNode`).
   module TreeTraversalCore
+    private
+
     # Returns FILTER_ACCEPT / FILTER_REJECT / FILTER_SKIP for the
     # given wrapped node.
-    def __accept__(node)
+    def accept(node)
       return NodeFilter::FILTER_REJECT unless node
       return NodeFilter::FILTER_SKIP if (NodeFilter.bitmask_for(node) & @what_to_show) == 0
 
@@ -55,8 +57,6 @@ module Dommy
       result || NodeFilter::FILTER_ACCEPT
     end
 
-    private
-
     def invoke_filter(node)
       return NodeFilter::FILTER_ACCEPT if @filter.nil?
 
@@ -92,7 +92,7 @@ module Dommy
     def next_node
       node = first_descendant_or_following(@current_node)
       while node
-        verdict = __accept__(node)
+        verdict = accept(node)
         if verdict == NodeFilter::FILTER_ACCEPT
           @current_node = node
           return node
@@ -109,7 +109,7 @@ module Dommy
     def previous_node
       node = preceding(@current_node)
       while node && node != @root
-        verdict = __accept__(node)
+        verdict = accept(node)
         if verdict == NodeFilter::FILTER_ACCEPT
           @current_node = node
           return node
@@ -124,7 +124,7 @@ module Dommy
     def parent_node
       node = wrapped_parent(@current_node)
       while node && reachable_from_root?(node)
-        return @current_node = node if __accept__(node) == NodeFilter::FILTER_ACCEPT
+        return @current_node = node if accept(node) == NodeFilter::FILTER_ACCEPT
 
         node = wrapped_parent(node)
       end
@@ -192,7 +192,7 @@ module Dommy
     def walk_siblings(start, direction)
       node = start
       while node
-        v = __accept__(node)
+        v = accept(node)
         return @current_node = node if v == NodeFilter::FILTER_ACCEPT
 
         node = (v == NodeFilter::FILTER_REJECT) ? nil : send(direction, node)
@@ -246,30 +246,30 @@ module Dommy
     end
 
     def wrapped_parent(node)
-      parent_nk = node.respond_to?(:__node__) ? node.__node__.parent : nil
-      return nil unless parent_nk && !parent_nk.is_a?(Nokogiri::XML::Document)
+      parent_nk = node.respond_to?(:__dommy_backend_node__) ? node.__dommy_backend_node__.parent : nil
+      return nil unless parent_nk && !parent_nk.is_a?(Backend.document_class)
 
       doc = node.instance_variable_get(:@document) || (@root.respond_to?(:document) ? @root.document : @root)
       doc.wrap_node(parent_nk)
     end
 
     def first_wrapped_child(node)
-      child_nk = node.respond_to?(:__node__) ? node.__node__.children.first : nil
+      child_nk = node.respond_to?(:__dommy_backend_node__) ? node.__dommy_backend_node__.children.first : nil
       child_nk && document_for(node).wrap_node(child_nk)
     end
 
     def last_wrapped_child(node)
-      child_nk = node.respond_to?(:__node__) ? node.__node__.children.last : nil
+      child_nk = node.respond_to?(:__dommy_backend_node__) ? node.__dommy_backend_node__.children.last : nil
       child_nk && document_for(node).wrap_node(child_nk)
     end
 
     def next_sibling_wrapped(node)
-      n = node.respond_to?(:__node__) ? node.__node__.next : nil
+      n = node.respond_to?(:__dommy_backend_node__) ? node.__dommy_backend_node__.next : nil
       n && document_for(node).wrap_node(n)
     end
 
     def previous_sibling_wrapped(node)
-      n = node.respond_to?(:__node__) ? node.__node__.previous : nil
+      n = node.respond_to?(:__dommy_backend_node__) ? node.__dommy_backend_node__.previous : nil
       n && document_for(node).wrap_node(n)
     end
 
@@ -306,7 +306,7 @@ module Dommy
 
         @reference_node = node
         @pointer_before_reference = false
-        return node if __accept__(node) == NodeFilter::FILTER_ACCEPT
+        return node if accept(node) == NodeFilter::FILTER_ACCEPT
       end
     end
 
@@ -322,7 +322,7 @@ module Dommy
 
         @reference_node = node
         @pointer_before_reference = true
-        return node if __accept__(node) == NodeFilter::FILTER_ACCEPT
+        return node if accept(node) == NodeFilter::FILTER_ACCEPT
       end
     end
 
@@ -392,28 +392,28 @@ module Dommy
     end
 
     def first_child_node(node)
-      n = node.respond_to?(:__node__) ? node.__node__.children.first : nil
+      n = node.respond_to?(:__dommy_backend_node__) ? node.__dommy_backend_node__.children.first : nil
       n && document_for(node).wrap_node(n)
     end
 
     def last_child_node(node)
-      n = node.respond_to?(:__node__) ? node.__node__.children.last : nil
+      n = node.respond_to?(:__dommy_backend_node__) ? node.__dommy_backend_node__.children.last : nil
       n && document_for(node).wrap_node(n)
     end
 
     def next_sibling_node(node)
-      n = node.respond_to?(:__node__) ? node.__node__.next : nil
+      n = node.respond_to?(:__dommy_backend_node__) ? node.__dommy_backend_node__.next : nil
       n && document_for(node).wrap_node(n)
     end
 
     def previous_sibling_node(node)
-      n = node.respond_to?(:__node__) ? node.__node__.previous : nil
+      n = node.respond_to?(:__dommy_backend_node__) ? node.__dommy_backend_node__.previous : nil
       n && document_for(node).wrap_node(n)
     end
 
     def parent_node_of(node)
-      parent_nk = node.respond_to?(:__node__) ? node.__node__.parent : nil
-      return nil unless parent_nk && !parent_nk.is_a?(Nokogiri::XML::Document)
+      parent_nk = node.respond_to?(:__dommy_backend_node__) ? node.__dommy_backend_node__.parent : nil
+      return nil unless parent_nk && !parent_nk.is_a?(Backend.document_class)
 
       document_for(node).wrap_node(parent_nk)
     end