dommy 0.5.0 → 0.7.0

data/lib/dommy/backend.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module Dommy
+  # `Dommy::Backend` — pluggable HTML parser abstraction. Lets Dommy
+  # work with either Nokogiri (mature, full namespace support) or
+  # Nokolexbor (faster, HTML5-only). Internally, all DOM library
+  # code goes through this facade rather than referencing the parser
+  # directly.
+  #
+  # Defaults to Nokogiri if available, else Nokolexbor.
+  #
+  # Switching backends:
+  #
+  #   require "dommy"
+  #   Dommy::Backend.use(:nokolexbor)
+  #
+  # Or set directly:
+  #
+  #   Dommy::Backend.current = Dommy::Backend::Nokolexbor
+  #
+  # All adapters must implement the same interface — see
+  # `Backend::Nokogiri` for the canonical reference.
+  module Backend
+    class BackendNotAvailable < StandardError
+    end
+
+    class << self
+      def current
+        @current ||= detect_default
+      end
+
+      attr_writer :current
+
+      def use(name)
+        @current = case name.to_sym
+        when :nokogiri
+          require_relative "backend/nokogiri_adapter"
+          Nokogiri
+        when :nokolexbor
+          require_relative "backend/nokolexbor_adapter"
+          Nokolexbor
+        else
+          raise ArgumentError, "Unknown backend: #{name.inspect}. Use :nokogiri or :nokolexbor."
+        end
+      end
+
+      # Delegate calls so internal code can use `Backend.parse(...)`.
+      def parse(html)
+        current.parse(html)
+      end
+
+      def fragment(html, owner_doc:)
+        current.fragment(html, owner_doc: owner_doc)
+      end
+
+      def create_element(name, doc)
+        current.create_element(name, doc)
+      end
+
+      def create_text(content, doc)
+        current.create_text(content, doc)
+      end
+
+      def create_comment(content, doc)
+        current.create_comment(content, doc)
+      end
+
+      def namespace_of(node)
+        current.namespace_of(node)
+      end
+
+      def add_namespace_definition(node, prefix, href)
+        current.add_namespace_definition(node, prefix, href)
+      end
+
+      # Type constants — proxy through to the current backend so
+      # `node.is_a?(Backend::Element)` resolves dynamically.
+      def element_class
+        current::Element
+      end
+
+      def document_class
+        current::Document
+      end
+
+      def text_class
+        current::Text
+      end
+
+      def comment_class
+        current::Comment
+      end
+
+      def document_fragment_class
+        current::DocumentFragment
+      end
+
+      def node_class
+        current::Node
+      end
+
+      private
+
+      def detect_default
+        try_nokogiri ||
+          try_nokolexbor ||
+          raise(BackendNotAvailable, "Dommy requires either 'nokogiri' or 'nokolexbor' gem to be installed.")
+      end
+
+      def try_nokogiri
+        require "nokogiri"
+
+        require_relative "backend/nokogiri_adapter"
+        Nokogiri
+      rescue LoadError
+        nil
+      end
+
+      def try_nokolexbor
+        require "nokolexbor"
+
+        require_relative "backend/nokolexbor_adapter"
+        Nokolexbor
+      rescue LoadError
+        nil
+      end
+    end
+  end
+end

data/lib/dommy/blob.rb

@@ -48,7 +48,7 @@ module Dommy
 
     # Raw binary bytes (Ruby ASCII-8BIT string). Used by FormData /
     # fetch when serializing multipart bodies.
-    def __bytes__
+    def __dommy_bytes__
       @data
     end
 
@@ -79,7 +79,7 @@ module Dommy
       parts.each do |part|
         case part
         when Blob
-          buf << part.__bytes__
+          buf << part.__dommy_bytes__
         when String
           buf << part.dup.force_encoding(Encoding::ASCII_8BIT)
         when Array

data/lib/dommy/compression_streams.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+require "zlib"
+require "stringio"
+
+module Dommy
+  # `CompressionStream` / `DecompressionStream` — wrap `TransformStream`
+  # over Ruby's `Zlib` to gzip/deflate/raw-deflate byte chunks. Each
+  # `write(chunk)` accumulates into an internal buffer; `close()`
+  # finalizes and emits the compressed/decompressed bytes downstream.
+  #
+  # Spec: https://wicg.github.io/compression/
+  class CompressionStream
+    SUPPORTED = %w[gzip deflate deflate-raw].freeze
+
+    attr_reader :readable, :writable
+
+    def initialize(window, format)
+      raise ArgumentError, "unsupported format #{format.inspect}" unless SUPPORTED.include?(format.to_s)
+
+      @buffer = +""
+      compressor = build_compressor(format.to_s)
+
+      @readable = ReadableStream.new(window)
+      controller = TransformStreamDefaultController.new(@readable)
+
+      @writable = WritableStream.new(
+        window,
+        {
+          "write" => proc { |chunk| @buffer << coerce(chunk) },
+          "close" => proc do
+            compressed = compressor.call(@buffer)
+            controller.enqueue(compressed)
+            @readable.__internal_close__
+          end,
+          "abort" => proc { |r| @readable.__internal_error__(r) }
+        }
+      )
+    end
+
+    def __js_get__(key)
+      case key
+      when "readable"
+        @readable
+      when "writable"
+        @writable
+      end
+    end
+
+    private
+
+    def coerce(chunk)
+      chunk.is_a?(Array) ? chunk.pack("C*") : chunk.to_s
+    end
+
+    def build_compressor(format)
+      case format
+      when "gzip"
+        proc do |data|
+          io = StringIO.new
+          gz = Zlib::GzipWriter.new(io)
+          gz.write(data)
+          gz.close
+          io.string.bytes
+        end
+
+      when "deflate"
+        proc { |data| Zlib::Deflate.deflate(data).bytes }
+      when "deflate-raw"
+        proc do |data|
+          z = Zlib::Deflate.new(Zlib::DEFAULT_COMPRESSION, -Zlib::MAX_WBITS)
+          out = z.deflate(data, Zlib::FINISH)
+          z.close
+          out.bytes
+        end
+      end
+    end
+  end
+
+  class DecompressionStream
+    SUPPORTED = %w[gzip deflate deflate-raw].freeze
+
+    attr_reader :readable, :writable
+
+    def initialize(window, format)
+      raise ArgumentError, "unsupported format #{format.inspect}" unless SUPPORTED.include?(format.to_s)
+
+      @buffer = +""
+      decompressor = build_decompressor(format.to_s)
+
+      @readable = ReadableStream.new(window)
+      controller = TransformStreamDefaultController.new(@readable)
+
+      @writable = WritableStream.new(
+        window,
+        {
+          "write" => proc { |chunk| @buffer << coerce(chunk) },
+          "close" => proc do
+            plain = decompressor.call(@buffer)
+            controller.enqueue(plain)
+            @readable.__internal_close__
+          end,
+          "abort" => proc { |r| @readable.__internal_error__(r) }
+        }
+      )
+    end
+
+    def __js_get__(key)
+      case key
+      when "readable"
+        @readable
+      when "writable"
+        @writable
+      end
+    end
+
+    private
+
+    def coerce(chunk)
+      chunk.is_a?(Array) ? chunk.pack("C*") : chunk.to_s
+    end
+
+    def build_decompressor(format)
+      case format
+      when "gzip"
+        proc do |data|
+          io = StringIO.new(data)
+          gz = Zlib::GzipReader.new(io)
+          out = gz.read
+          gz.close
+          out.bytes
+        end
+
+      when "deflate"
+        proc { |data| Zlib::Inflate.inflate(data).bytes }
+      when "deflate-raw"
+        proc do |data|
+          z = Zlib::Inflate.new(-Zlib::MAX_WBITS)
+          out = z.inflate(data)
+          z.finish
+          z.close
+          out.bytes
+        end
+      end
+    end
+  end
+end

data/lib/dommy/cookie_store.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+module Dommy
+  # `cookieStore` — the asynchronous Cookie Store API. Reads and
+  # writes go through the existing `Document#cookie_jar`, so values
+  # set via `document.cookie = ...` round-trip via `cookieStore.get`.
+  #
+  # Spec: https://wicg.github.io/cookie-store/
+  class CookieStore
+    include EventTarget
+
+    def initialize(window)
+      @window = window
+    end
+
+    def get(name_or_options)
+      name = name_or_options.is_a?(Hash) ? (name_or_options["name"] || name_or_options[:name]) : name_or_options
+      raw = cookie_jar.cookies[name.to_s]
+      raw ? PromiseValue.resolve(@window, build_record(name.to_s, raw)) : PromiseValue.resolve(@window, nil)
+    end
+
+    def get_all(name = nil)
+      records = cookie_jar.cookies.map { |k, v| build_record(k, v) }
+      records = records.select { |r| r["name"] == name.to_s } if name
+      PromiseValue.resolve(@window, records)
+    end
+
+    alias getAll get_all
+
+    def set(name_or_options, value = nil)
+      if name_or_options.is_a?(Hash)
+        opts = name_or_options.transform_keys(&:to_s)
+        name = opts["name"]
+        value = opts["value"]
+      else
+        name = name_or_options
+      end
+
+      cookie_jar.set_cookie("#{name}=#{value}")
+      dispatch_event(
+        CookieChangeEvent.new(
+          "change",
+          "changed" => [build_record(name.to_s, value.to_s)],
+          "deleted" => []
+        )
+      )
+      PromiseValue.resolve(@window, nil)
+    end
+
+    def delete(name_or_options)
+      name = name_or_options.is_a?(Hash) ? (name_or_options["name"] || name_or_options[:name]) : name_or_options
+      cookie_jar.cookies.delete(name.to_s)
+      dispatch_event(
+        CookieChangeEvent.new(
+          "change",
+          "changed" => [],
+          "deleted" => [build_record(name.to_s, "")]
+        )
+      )
+      PromiseValue.resolve(@window, nil)
+    end
+
+    def __js_call__(method, args)
+      case method
+      when "get"
+        get(args[0])
+      when "getAll"
+        get_all(args[0])
+      when "set"
+        set(args[0], args[1])
+      when "delete"
+        delete(args[0])
+      when "addEventListener"
+        add_event_listener(args[0], args[1], args[2])
+      when "removeEventListener"
+        remove_event_listener(args[0], args[1])
+      when "dispatchEvent"
+        dispatch_event(args[0])
+      end
+    end
+
+    def __internal_event_parent__
+      nil
+    end
+
+    private
+
+    def cookie_jar
+      # `document.cookie_jar` is private; we reach the same backing
+      # store via the public `document.cookie` round-trip. Easier: use
+      # instance_variable_get on the document.
+      @window.document.instance_variable_get(:@cookie_jar)
+    end
+
+    def build_record(name, value)
+      {
+        "name" => name.to_s,
+        "value" => value.to_s,
+        "domain" => nil,
+        "path" => "/",
+        "expires" => nil,
+        "secure" => false,
+        "sameSite" => "strict"
+      }
+    end
+  end
+
+  class CookieChangeEvent < Event
+    def initialize(type, init = nil)
+      super
+      @changed = Array(read_init(init, "changed") || [])
+      @deleted = Array(read_init(init, "deleted") || [])
+    end
+
+    attr_reader :changed, :deleted
+
+    def __js_get__(key)
+      case key
+      when "changed"
+        @changed
+      when "deleted"
+        @deleted
+      else
+        super
+      end
+    end
+  end
+end