dommy 0.12.0 → 0.13.0

data/lib/dommy/encodings.rb

@@ -0,0 +1,299 @@
+# frozen_string_literal: true
+
+require_relative "encodings/tables"
+
+module Dommy
+  # The Encoding Standard's encodings: every label it knows, and a decoder for
+  # each encoding that turns bytes into code points, streaming, with the
+  # replacement-or-throw error mode TextDecoder exposes as `fatal`.
+  #
+  # UTF-8, UTF-16 and the legacy single-byte encodings are decoded here, from
+  # the spec's own algorithms and index tables. The legacy multi-byte
+  # encodings (Big5, EUC-JP, ISO-2022-JP, Shift_JIS, EUC-KR, GBK, gb18030) go
+  # through Ruby's converters for the encoding closest to the spec's index,
+  # which differ from it in a few code points and in how many U+FFFD a broken
+  # sequence yields.
+  #
+  # Spec: https://encoding.spec.whatwg.org/
+  module Encodings
+    # The Ruby encoding whose mapping is closest to the spec's index for each
+    # legacy multi-byte encoding.
+    RUBY_ENCODINGS = {
+      "Big5" => "Big5-HKSCS",
+      "EUC-JP" => "EUC-JP",
+      "ISO-2022-JP" => "ISO-2022-JP",
+      "Shift_JIS" => "Windows-31J",
+      "EUC-KR" => "CP949",
+      "GBK" => "GBK",
+      "gb18030" => "GB18030"
+    }.freeze
+
+    REPLACEMENT_CHARACTER = 0xFFFD
+
+    # The name of the encoding `label` stands for, or nil. Only ASCII
+    # whitespace around the label is ignored.
+    #
+    # Spec: https://encoding.spec.whatwg.org/#concept-encoding-get
+    def self.get(label)
+      LABELS[label.gsub(/\A[\t\n\f\r ]+|[\t\n\f\r ]+\z/, "").downcase]
+    end
+
+    # The charset parameter of a MIME type string, or nil.
+    def self.charset_of(mime_type)
+      match = mime_type.to_s.match(/;\s*charset\s*=\s*(?:"([^"]*)"|([^\s;]*))/i)
+      match && (match[1] || match[2])
+    end
+
+    # Bytes to a String in `fallback` (an encoding name), unless they start
+    # with a byte-order mark, which names the encoding itself and is dropped.
+    # Errors are U+FFFD.
+    #
+    # Spec: https://encoding.spec.whatwg.org/#decode
+    def self.decode(bytes, fallback = "UTF-8")
+      bytes = bytes.b
+      name = fallback
+      if bytes.start_with?("\xEF\xBB\xBF".b)
+        name = "UTF-8"
+        bytes = bytes.byteslice(3..)
+      elsif bytes.start_with?("\xFE\xFF".b)
+        name = "UTF-16BE"
+        bytes = bytes.byteslice(2..)
+      elsif bytes.start_with?("\xFF\xFE".b)
+        name = "UTF-16LE"
+        bytes = bytes.byteslice(2..)
+      end
+      decoder_for(name).decode(bytes, flush: true).pack("U*")
+    end
+
+    # A fresh decoder for the encoding named `name` (as `get` returns it).
+    def self.decoder_for(name, fatal: false)
+      case name
+      when "UTF-8" then Utf8Decoder.new(fatal)
+      when "UTF-16LE" then Utf16Decoder.new(fatal, big_endian: false)
+      when "UTF-16BE" then Utf16Decoder.new(fatal, big_endian: true)
+      when "x-user-defined" then XUserDefinedDecoder.new(fatal)
+      when "replacement" then ReplacementDecoder.new(fatal)
+      else
+        index = SINGLE_BYTE_INDEXES[name]
+        return SingleByteDecoder.new(fatal, index) if index
+
+        ConverterDecoder.new(fatal, RUBY_ENCODINGS.fetch(name))
+      end
+    end
+
+    # What every decoder shares: `decode(bytes, flush:)` takes a binary String
+    # and returns the code points it yields, keeping whatever partial sequence
+    # is left over for the next call unless `flush` is true. An error is
+    # U+FFFD, or a TypeError in fatal mode.
+    class Decoder
+      def initialize(fatal)
+        @fatal = fatal
+      end
+
+      private
+
+      def error
+        raise Bridge::TypeError, "The encoded data was not valid" if @fatal
+
+        REPLACEMENT_CHARACTER
+      end
+    end
+
+    # Spec: https://encoding.spec.whatwg.org/#utf-8-decoder
+    class Utf8Decoder < Decoder
+      def initialize(fatal)
+        super
+        reset
+      end
+
+      def decode(bytes, flush:)
+        out = []
+        queue = bytes.bytes
+        until queue.empty?
+          byte = queue.shift
+          if @needed.zero?
+            if byte <= 0x7F
+              out << byte
+            elsif byte.between?(0xC2, 0xDF)
+              @needed = 1
+              @code_point = byte & 0x1F
+            elsif byte.between?(0xE0, 0xEF)
+              @lower = 0xA0 if byte == 0xE0
+              @upper = 0x9F if byte == 0xED
+              @needed = 2
+              @code_point = byte & 0x0F
+            elsif byte.between?(0xF0, 0xF4)
+              @lower = 0x90 if byte == 0xF0
+              @upper = 0x8F if byte == 0xF4
+              @needed = 3
+              @code_point = byte & 0x07
+            else
+              out << error
+            end
+            next
+          end
+
+          unless byte.between?(@lower, @upper)
+            # Not a continuation byte: an error, and the byte is read again.
+            reset
+            out << error
+            queue.unshift(byte)
+            next
+          end
+
+          @lower = 0x80
+          @upper = 0xBF
+          @code_point = (@code_point << 6) | (byte & 0x3F)
+          @seen += 1
+          next unless @seen == @needed
+
+          out << @code_point
+          reset
+        end
+
+        if flush && @needed != 0
+          reset
+          out << error
+        end
+        out
+      end
+
+      private
+
+      def reset
+        @needed = 0
+        @seen = 0
+        @code_point = 0
+        @lower = 0x80
+        @upper = 0xBF
+      end
+    end
+
+    # Spec: https://encoding.spec.whatwg.org/#shared-utf-16-decoder
+    class Utf16Decoder < Decoder
+      def initialize(fatal, big_endian:)
+        super(fatal)
+        @big_endian = big_endian
+        @lead_byte = nil
+        @lead_surrogate = nil
+      end
+
+      def decode(bytes, flush:)
+        out = []
+        bytes.each_byte do |byte|
+          if @lead_byte.nil?
+            @lead_byte = byte
+            next
+          end
+
+          code_unit = @big_endian ? ((@lead_byte << 8) + byte) : ((byte << 8) + @lead_byte)
+          @lead_byte = nil
+
+          if @lead_surrogate
+            lead_surrogate = @lead_surrogate
+            @lead_surrogate = nil
+            if code_unit.between?(0xDC00, 0xDFFF)
+              out << (0x10000 + ((lead_surrogate - 0xD800) << 10) + (code_unit - 0xDC00))
+              next
+            end
+            # The lead surrogate had no trail: an error, and the code unit's
+            # bytes are read again.
+            out << error
+            out.concat(decode_code_unit(code_unit))
+            next
+          end
+
+          out.concat(decode_code_unit(code_unit))
+        end
+
+        if flush && (@lead_byte || @lead_surrogate)
+          @lead_byte = nil
+          @lead_surrogate = nil
+          out << error
+        end
+        out
+      end
+
+      private
+
+      def decode_code_unit(code_unit)
+        if code_unit.between?(0xD800, 0xDBFF)
+          @lead_surrogate = code_unit
+          []
+        elsif code_unit.between?(0xDC00, 0xDFFF)
+          [error]
+        else
+          [code_unit]
+        end
+      end
+    end
+
+    # Spec: https://encoding.spec.whatwg.org/#single-byte-decoder
+    class SingleByteDecoder < Decoder
+      def initialize(fatal, index)
+        super(fatal)
+        @index = index
+      end
+
+      def decode(bytes, flush:)
+        bytes.each_byte.map do |byte|
+          if byte <= 0x7F
+            byte
+          else
+            @index[byte - 0x80] || error
+          end
+        end
+      end
+    end
+
+    # Spec: https://encoding.spec.whatwg.org/#x-user-defined-decoder
+    class XUserDefinedDecoder < Decoder
+      def decode(bytes, flush:)
+        bytes.each_byte.map { |byte| byte <= 0x7F ? byte : 0xF780 + byte - 0x80 }
+      end
+    end
+
+    # The whole stream is one error, reported once.
+    #
+    # Spec: https://encoding.spec.whatwg.org/#replacement-decoder
+    class ReplacementDecoder < Decoder
+      def initialize(fatal)
+        super
+        @reported = false
+      end
+
+      def decode(bytes, flush:)
+        return [] if bytes.empty? || @reported
+
+        @reported = true
+        [error]
+      end
+    end
+
+    # A legacy multi-byte encoding, through Ruby's converter. Partial input is
+    # held between calls; at a flush what is left over is an error.
+    class ConverterDecoder < Decoder
+      def initialize(fatal, ruby_encoding)
+        super(fatal)
+        options = fatal ? {} : {invalid: :replace, undef: :replace, replace: "\uFFFD"}
+        @converter = ::Encoding::Converter.new(ruby_encoding, "UTF-8", **options)
+      end
+
+      def decode(bytes, flush:)
+        output = +""
+        result = @converter.primitive_convert(bytes.dup, output, nil, nil, partial_input: !flush)
+        code_points = output.codepoints
+        case result
+        when :finished, :source_buffer_empty
+          code_points
+        when :incomplete_input, :invalid_byte_sequence, :undefined_conversion
+          # Only reached in fatal mode, or by an incomplete sequence at a
+          # flush; either way the stream is over.
+          code_points << error
+        else
+          code_points
+        end
+      end
+    end
+  end
+end

data/lib/dommy/event.rb

@@ -473,15 +473,14 @@ module Dommy
     # exception reported as an `error` event at the relevant global (the Window),
     # so `window.onerror` / an "error" listener sees it. The error value is the
     # thrown value itself — a JS value keeps its identity (via ThrowValue), so
-    # `event.error === thrown`. No window (a node in a windowless document, or a
-    # target that has none) → nothing to report to.
+    # `event.error === thrown`; the Ruby exception rides along as `host_error` so
+    # an unhandled report reaches the host with its backtrace. No window (a node
+    # in a windowless document, or a target that has none) → nothing to report to.
     def __internal_report_listener_exception__(error)
       win = window_of(self)
       return unless win.respond_to?(:__internal_report_exception__)
 
-      value = error.is_a?(Bridge::ThrowValue) ? error.value : error
-      message = value.respond_to?(:message) ? value.message.to_s : value.to_s
-      win.__internal_report_exception__(value, message)
+      Internal::ExceptionReport.report_at(win, error)
     end
 
     # Diagnostic only (DOMMY_EVENT_DEBUG=<file>): when a listener throws, append

data/lib/dommy/fetch.rb

@@ -557,6 +557,60 @@ module Dommy
     end
   end
 
+  # The `formData()` half of the Body mixin, shared by Request and Response:
+  # the body parsed as a FormData by its Content-Type. The including class
+  # provides `@headers`, `@window`, `immediate` and `rejected`.
+  module FormDataBody
+    private
+
+    # WHATWG: parse the body as a FormData based on Content-Type —
+    # application/x-www-form-urlencoded or multipart/form-data. Any other type
+    # rejects with a TypeError.
+    def consume_form_data(body)
+      content_type = (@headers.__js_call__("get", ["content-type"]) || "").to_s
+      if content_type.start_with?("application/x-www-form-urlencoded")
+        immediate(parse_urlencoded_form(body))
+      elsif (match = content_type.match(/\bmultipart\/form-data\b.*?boundary=("?)([^";]+)\1/i))
+        immediate(parse_multipart_form(body, match[2]))
+      else
+        rejected(ErrorValue.new("Failed to read body as FormData: unsupported Content-Type", name: "TypeError"))
+      end
+    end
+
+    def parse_urlencoded_form(body)
+      form = FormData.new
+      URLSearchParams.new(body).__js_call__("entries", []).each { |name, value| form.append(name, value) }
+      form
+    end
+
+    # Parse a multipart/form-data body (the inverse of Response.multipart_body):
+    # a part with a `filename` becomes a File entry, otherwise a string entry.
+    def parse_multipart_form(body, boundary)
+      form = FormData.new
+      body.split("--#{boundary}").each do |section|
+        next if section.empty? || section.start_with?("--") # preamble / closing
+
+        section = section.sub(/\A\r\n/, "")
+        head, content = section.split("\r\n\r\n", 2)
+        next unless content
+
+        content = content.sub(/\r\n\z/, "")
+        disposition = head[/Content-Disposition:\s*form-data;([^\r\n]*)/i, 1].to_s
+        name = disposition[/name="([^"]*)"/i, 1]
+        next unless name
+
+        filename = disposition[/filename="([^"]*)"/i, 1]
+        if filename
+          type = head[/Content-Type:\s*([^\r\n]+)/i, 1].to_s.strip
+          form.append(name, File.new([content], filename, {"type" => type}, @window))
+        else
+          form.append(name, content)
+        end
+      end
+      form
+    end
+  end
+
   # `Request` polyfill — minimal Fetch API Request object so callers
   # constructing `new Request(url, init)` get a value with `.url`,
   # `.method`, `.headers`, `.body`. The stub-based `fetch` doesn't
@@ -626,7 +680,8 @@ module Dommy
     end
 
     include Bridge::Methods
-    js_methods %w[clone text json arrayBuffer blob bytes]
+    include FormDataBody
+    js_methods %w[clone text json arrayBuffer blob bytes formData]
     def __js_call__(method, _args)
       case method
       when "clone"
@@ -659,6 +714,8 @@ module Dommy
       when "blob"
         ct = @headers.__js_call__("get", ["content-type"]) || ""
         consume_body { immediate(Blob.new([@body_bytes], {"type" => ct}, @window)) }
+      when "formData"
+        consume_body { consume_form_data(@body_bytes) }
       end
     end
 
@@ -946,6 +1003,7 @@ module Dommy
     end
 
     include Bridge::Methods
+    include FormDataBody
     js_methods %w[text json arrayBuffer blob formData clone]
     def __js_call__(method, _args)
       case method
@@ -966,7 +1024,7 @@ module Dommy
           immediate(Blob.new([@body], {"type" => @headers.__js_call__("get", ["content-type"]) || ""}, @window))
         end
       when "formData"
-        consume_body { consume_form_data }
+        consume_body { consume_form_data(@body) }
       when "clone"
         clone_response
       end
@@ -1004,53 +1062,6 @@ module Dommy
       end
     end
 
-    # WHATWG: parse the body as a FormData based on Content-Type —
-    # application/x-www-form-urlencoded or multipart/form-data. Any other type
-    # rejects with a TypeError.
-    def consume_form_data
-      content_type = (@headers.__js_call__("get", ["content-type"]) || "").to_s
-      if content_type.start_with?("application/x-www-form-urlencoded")
-        immediate(parse_urlencoded_form(@body))
-      elsif (match = content_type.match(/\bmultipart\/form-data\b.*?boundary=("?)([^";]+)\1/i))
-        immediate(parse_multipart_form(@body, match[2]))
-      else
-        rejected(ErrorValue.new("Failed to read body as FormData: unsupported Content-Type", name: "TypeError"))
-      end
-    end
-
-    def parse_urlencoded_form(body)
-      form = FormData.new
-      URLSearchParams.new(body).__js_call__("entries", []).each { |name, value| form.append(name, value) }
-      form
-    end
-
-    # Parse a multipart/form-data body (the inverse of Response.multipart_body):
-    # a part with a `filename` becomes a File entry, otherwise a string entry.
-    def parse_multipart_form(body, boundary)
-      form = FormData.new
-      body.split("--#{boundary}").each do |section|
-        next if section.empty? || section.start_with?("--") # preamble / closing
-
-        section = section.sub(/\A\r\n/, "")
-        head, content = section.split("\r\n\r\n", 2)
-        next unless content
-
-        content = content.sub(/\r\n\z/, "")
-        disposition = head[/Content-Disposition:\s*form-data;([^\r\n]*)/i, 1].to_s
-        name = disposition[/name="([^"]*)"/i, 1]
-        next unless name
-
-        filename = disposition[/filename="([^"]*)"/i, 1]
-        if filename
-          type = head[/Content-Type:\s*([^\r\n]+)/i, 1].to_s.strip
-          form.append(name, File.new([content], filename, {"type" => type}, @window))
-        else
-          form.append(name, content)
-        end
-      end
-      form
-    end
-
     # WHATWG: clone throws if the body is already disturbed/locked; otherwise the
     # clone is an independent Response over the same bytes.
     def clone_response

data/lib/dommy/form_data.rb

@@ -15,6 +15,16 @@ module Dommy
   class FormData
     include Enumerable
 
+    # `new FormData(form)` from JavaScript: an absent or undefined form means
+    # an empty FormData; null or anything but a form element is a TypeError,
+    # since the argument is a non-nullable HTMLFormElement.
+    def self.from_js(args)
+      return new if args.empty? || args[0].equal?(Bridge::UNDEFINED)
+      raise Bridge::TypeError, "FormData constructor: argument 1 is not an HTMLFormElement" unless args[0].is_a?(HTMLFormElement)
+
+      new(args[0])
+    end
+
     def initialize(form = nil)
       @pairs = []
       collect_from(form) if form