dommy 0.16.0 → 0.17.0

data/lib/dommy/fetch.rb

@@ -2,7 +2,9 @@
 
 require "json"
 require "securerandom"
+require "weakref"
 require_relative "data_uri"
+require_relative "internal/referrer"
 
 module Dommy
   # `fetch` polyfill. No real network — instead resolves a response
@@ -36,8 +38,30 @@ module Dommy
       # Per Fetch, the request URL is resolved against the document base URL up
       # front; the handler, stub maps, and response.url all see the absolute
       # URL (no per-handler resolution).
-      url = @window.__internal_resolve_url__(args[0].to_s)
-      init = normalize_init(args[1] || {})
+      input, init = args
+      # fetch(request, init) is a fetch of `new Request(request, init)`: the
+      # request's URL, and its members as far as `init` leaves them.
+      body_source = nil
+      if input.is_a?(Request)
+        given = init.is_a?(Hash) ? init.transform_keys(&:to_s) : {}
+        # A null (or undefined) body in `init` leaves the request's own.
+        given.delete("body") if given["body"].nil? || given["body"].equal?(Bridge::UNDEFINED)
+        body_source = input unless given.key?("body")
+        init = input.__internal_init__.merge(given)
+        input = input.url
+      end
+      url = @window.__internal_resolve_url__(input.to_s, utf8: true)
+      init = normalize_init(init || {})
+      begin
+        add_referer(url, init)
+      rescue Bridge::TypeError => e
+        return PromiseValue.reject(@window, e)
+      end
+      # Sending the request's body uses it up, as reading it would — once the
+      # new Request's members are valid, as its constructor takes it last.
+      if body_source && !body_source.__internal_take_body__
+        return PromiseValue.reject(@window, Bridge::TypeError.new("Failed to execute 'fetch': Request body is already used"))
+      end
       # A cross-origin request always carries an Origin header (even for GET,
       # which normalize_init omits it for same-origin GETs).
       if cross_origin?(url) && !header?(init["headers"], "origin")
@@ -53,6 +77,16 @@ module Dommy
       @window.globals["__last_body__"] = init["body"] if init.is_a?(Hash)
 
       promise = PromiseValue.new(@window)
+      # An aborted signal rejects the fetch with its reason: before anything is
+      # sent when it already is, else whenever it aborts until the response
+      # arrives (the request has reached the app by then, as it would a server).
+      if (signal = request_signal(init))
+        return promise.reject(signal.reason) if signal.aborted?
+
+        abort_fetch = proc { promise.reject(signal.reason) }
+        signal.__internal_add_abort_algorithm__(abort_fetch)
+        promise.__internal_when_settled__ { signal.__internal_remove_abort_algorithm__(abort_fetch) }
+      end
       # `mode: "same-origin"` forbids a cross-origin request — it is a network
       # error before any fetch happens.
       if (init["mode"] || "cors").to_s == "same-origin" && cross_origin?(url)
@@ -270,8 +304,11 @@ module Dommy
     end
 
     def deliver_entry(promise, entry, url, init)
+      # Aborted while the response was on its way.
+      return if promise.settled?
+
       if entry.nil?
-        promise.fulfill(Response.new(@window, body: "not found", status: 404, status_text: "Not Found", type: "basic"))
+        fulfill_response(promise, Response.new(@window, body: "not found", status: 404, status_text: "Not Found", type: "basic"), init)
         return
       end
 
@@ -292,13 +329,30 @@ module Dommy
       if (delay = entry["delay"])
         install_delayed_resolve(promise, body, status, status_text, headers, init, delay)
       else
-        promise.fulfill(
+        fulfill_response(
+          promise,
           Response.new(@window, body: body, status: status, status_text: status_text,
-            headers: headers, url: response_url, redirected: redirected, type: entry["type"] || "basic")
+            headers: headers, url: response_url, redirected: redirected, type: entry["type"] || "basic"),
+          init
         )
       end
     end
 
+    # The fetch's AbortSignal (`init.signal`, a Request's own), or nil.
+    def request_signal(init)
+      signal = init["signal"]
+      signal if signal.is_a?(AbortSignal)
+    end
+
+    # Fulfill the fetch with its response, whose body an abort of the signal
+    # errors from then on (Fetch's "abort the fetch() call" with a response).
+    def fulfill_response(promise, response, init)
+      if (signal = request_signal(init))
+        response.__internal_follow_abort__(signal)
+      end
+      promise.fulfill(response)
+    end
+
     # Resolve the response entry for a request: a `__fetch_handler__`
     # callable gets first refusal; a nil from it (or no handler) falls
     # through to the stub maps. Each spec file installs its stub under
@@ -378,6 +432,19 @@ module Dommy
       headers
     end
 
+    # The Referer the page's request carries (Referrer Policy), in place of
+    # any the caller gave: a forbidden request header is the browser's to set.
+    def add_referer(url, init)
+      headers = init["headers"]
+      headers.delete_if { |name, _| name.to_s.casecmp?("referer") }
+      referer = Internal::Referrer.header_value(
+        @window, url,
+        referrer: Internal::Referrer.request_referrer(@window, init["referrer"]),
+        policy: Internal::Referrer.request_policy(init["referrerPolicy"])
+      )
+      headers["Referer"] = referer if referer
+    end
+
     def request_origin
       @window.location.__js_get__("origin").to_s
     rescue StandardError
@@ -417,7 +484,7 @@ module Dommy
     end
 
     def safe_content_type?(value)
-      CORS_SAFE_CONTENT_TYPES.include?(value.to_s.split(";").first.to_s.strip.downcase)
+      CORS_SAFE_CONTENT_TYPES.include?(Internal::MimeType.essence(value))
     end
 
     # Run the CORS preflight (an OPTIONS carrying Access-Control-Request-Method /
@@ -528,32 +595,22 @@ module Dommy
       nil
     end
 
+    # Fulfill after a simulated `delay`. An abort before then rejects the fetch
+    # (see #__js_call__) and clears the timer, so it does not linger in the
+    # scheduler's queue.
     def install_delayed_resolve(promise, body, status, status_text, headers, init, delay_ms)
-      # AbortController cancellation: when init.signal is present and
-      # `.abort()` fires before the timer, reject with an AbortError.
-      # The timer is cleared in that path so it doesn't leak through
-      # the test scheduler's drain loop.
-      cancelled = [false]
+      signal = request_signal(init)
+      clear_timer = nil
       timer_id = @window.scheduler.set_timeout(
         lambda do |*_args|
-          next if cancelled[0]
-
-          promise.fulfill(Response.new(@window, body: body, status: status, status_text: status_text, headers: headers, type: "basic"))
+          signal&.__internal_remove_abort_algorithm__(clear_timer)
+          fulfill_response(promise, Response.new(@window, body: body, status: status, status_text: status_text, headers: headers, type: "basic"), init)
         end,
         delay_ms.to_i
       )
-      signal = init.is_a?(Hash) ? init["signal"] : nil
-      return unless signal.is_a?(AbortSignal)
-
-      window_ref = @window
-      abort_cb = lambda do |*_args|
-        cancelled[0] = true
-        window_ref.scheduler.clear_timeout(timer_id)
-        err = ErrorValue.new("aborted", name: "AbortError")
-        promise.reject(err)
-      end
-
-      signal.__js_call__("addEventListener", ["abort", abort_cb])
+      scheduler = @window.scheduler
+      clear_timer = proc { scheduler.clear_timeout(timer_id) }
+      signal&.__internal_add_abort_algorithm__(clear_timer)
     end
   end
 
@@ -613,10 +670,7 @@ module Dommy
 
   # `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
-  # consume it directly (it still takes `(url, init)`), but having
-  # Request available means JS code that constructs one before
-  # passing to fetch keeps working.
+  # `.method`, `.headers`, `.body`, which `fetch(request)` sends.
   class Request
     attr_reader :url, :method, :body
 
@@ -650,9 +704,11 @@ module Dommy
       # `request.signal.removeEventListener` crash.
       sig = opts["signal"] || opts[:signal]
       @signal = sig.is_a?(AbortSignal) ? sig : AbortSignal.new
+      @referrer = Internal::Referrer.request_referrer(window, opts["referrer"] || opts[:referrer])
+      @referrer_policy = Internal::Referrer.request_policy(opts["referrerPolicy"] || opts[:referrerPolicy])
     end
 
-    attr_reader :headers, :credentials, :mode, :cache, :redirect, :signal
+    attr_reader :headers, :credentials, :mode, :cache, :redirect, :signal, :referrer, :referrer_policy
 
     def __js_get__(key)
       case key
@@ -664,6 +720,8 @@ module Dommy
         @headers
       when "body"
         @body
+      when "bodyUsed"
+        @body_used == true
       when "credentials"
         @credentials
       when "mode"
@@ -674,6 +732,10 @@ module Dommy
         @redirect
       when "signal"
         @signal
+      when "referrer"
+        @referrer
+      when "referrerPolicy"
+        @referrer_policy
       else
         Bridge::ABSENT
       end
@@ -685,25 +747,14 @@ module Dommy
     def __js_call__(method, _args)
       case method
       when "clone"
-        Request.new(
-          @url,
-          {
-            "method" => @method,
-            "body" => @body,
-            "headers" => @headers.to_h,
-            "credentials" => @credentials,
-            "mode" => @mode,
-            "cache" => @cache,
-            "redirect" => @redirect,
-            "signal" => @signal
-          },
-          @window
-        )
+        raise Bridge::TypeError, "Failed to execute 'clone' on 'Request': Request body is already used" if @body_used
+
+        Request.new(@url, __internal_init__, @window)
       when "text"
         consume_body { immediate(Response.utf8_decode(@body_bytes)) }
       when "json"
         consume_body do
-          immediate(JSON.parse(Response.utf8_decode(@body_bytes)))
+          immediate(JSON.parse(Response.utf8_decode(@body_bytes), **Response::JSON_OPTIONS))
         rescue JSON::ParserError => e
           rejected(ErrorValue.new("JSON parse: #{e.message}"))
         end
@@ -719,19 +770,49 @@ module Dommy
       end
     end
 
+    # fetch(request) sends the body: false when it was already used, else it
+    # is used now. A request with no body has nothing to use up.
+    def __internal_take_body__
+      return true unless body?
+      return false if @body_used
+
+      @body_used = true
+    end
+
+    # The request as a `RequestInit`: what `clone()` builds a copy from, and
+    # what `fetch(request, init)` starts from before `init` overrides it.
+    def __internal_init__
+      {
+        "method" => @method,
+        "body" => @body,
+        "headers" => @headers.to_h,
+        "credentials" => @credentials,
+        "mode" => @mode,
+        "cache" => @cache,
+        "redirect" => @redirect,
+        "signal" => @signal,
+        "referrer" => @referrer,
+        "referrerPolicy" => @referrer_policy
+      }
+    end
+
     private
 
     # WHATWG Body: the body can be consumed once. A second consume rejects rather
-    # than throwing synchronously.
+    # than throwing synchronously. A request with no body has nothing to use
+    # up: reading it leaves `bodyUsed` false, and it can be read and cloned
+    # again.
     def consume_body
       if @body_used
         return rejected(ErrorValue.new("Failed to read body: body stream already read", name: "TypeError"))
       end
 
-      @body_used = true
+      @body_used = true if body?
       yield
     end
 
+    def body? = !@body.nil? && !@body.equal?(Bridge::UNDEFINED)
+
     def immediate(value)
       @window ? PromiseValue.resolve(@window, value) : value
     end
@@ -772,6 +853,7 @@ module Dommy
       @type = type
       @has_body = has_body ? true : false
       @body_used = false
+      @body_error = nil
       @body_stream = nil
     end
 
@@ -909,6 +991,10 @@ module Dommy
       end
     end
 
+    # ECMAScript's JSON.parse, which a page's JSON goes through, keeps the last
+    # of duplicate keys; json 3 rejects them unless told otherwise.
+    JSON_OPTIONS = {allow_duplicate_key: true}.freeze
+
     # WHATWG "UTF-8 decode" for a body's text(): interpret the raw bytes as
     # UTF-8, replacing any ill-formed sequence with U+FFFD, and drop a single
     # leading byte-order mark (U+FEFF). Well-formed UTF-8 (the common case) is
@@ -1002,6 +1088,68 @@ module Dommy
       Bridge::UNHANDLED
     end
 
+    # The response's fetch can still be aborted through `signal` (Fetch's
+    # "abort the fetch() call" with a response): a body not yet read errors
+    # with the abort reason, for a consume method and for a reader of `body`
+    # alike. The signal lets go once the body is read — by a consume method,
+    # or a reader taking it to its end — and holds the response and its body
+    # stream only weakly until then, so a long-lived signal does not keep a
+    # response nobody reads (`fetch(url, {signal}).then(r => r.ok)`).
+    def __internal_follow_abort__(signal)
+      return unless body_readable?
+
+      @abort_signal = signal
+      @abort_body = BodyAbort.new(self, signal)
+      signal.__internal_remove_abort_algorithms_if__ { |algorithm| algorithm.is_a?(BodyAbort) && algorithm.gone? }
+      signal.__internal_add_abort_algorithm__(@abort_body)
+    end
+
+    # The abort algorithm a Response leaves on its fetch's signal. It errors
+    # the body when the response is still around, else the body stream a
+    # reader may still hold; once both have been collected there is nothing
+    # left to abort, and the signal drops it the next time it takes one.
+    class BodyAbort
+      def initialize(response, signal)
+        @response = WeakRef.new(response)
+        @stream = nil
+        @signal = signal
+      end
+
+      def stream=(stream)
+        @stream = WeakRef.new(stream)
+      end
+
+      def gone?
+        !alive(@response) && !alive(@stream)
+      end
+
+      # The stream was read to its end or errored: nothing left to abort.
+      def release
+        @signal.__internal_remove_abort_algorithm__(self)
+      end
+
+      def call
+        if (response = alive(@response))
+          response.__internal_abort_body__(@signal.reason)
+        elsif (stream = alive(@stream)) && stream.state == :readable
+          stream.__internal_error__(@signal.reason)
+        end
+      end
+
+      private
+
+      def alive(ref)
+        ref&.weakref_alive? ? ref.__getobj__ : nil
+      rescue WeakRef::RefError
+        nil
+      end
+    end
+
+    # Fetch "error response's body" from the signal's abort algorithm.
+    def __internal_abort_body__(reason)
+      abort_body(reason)
+    end
+
     include Bridge::Methods
     include FormDataBody
     js_methods %w[text json arrayBuffer blob formData clone]
@@ -1011,7 +1159,7 @@ module Dommy
         consume_body { immediate(Response.utf8_decode(@body)) }
       when "json"
         consume_body do
-          immediate(JSON.parse(scrub_lone_surrogates(@body)))
+          immediate(JSON.parse(scrub_lone_surrogates(@body), **Response::JSON_OPTIONS))
         rescue JSON::ParserError => e
           rejected(ErrorValue.new("JSON parse: #{e.message}"))
         end
@@ -1039,16 +1187,37 @@ module Dommy
     end
 
     # Run a body-consume (text/json/arrayBuffer/blob), rejecting if the body was
-    # already used (spec returns a rejected promise, not a synchronous throw).
+    # already used (spec returns a rejected promise, not a synchronous throw),
+    # or with the abort reason when its fetch was aborted before it was read.
     def consume_body
       if body_used?
         return rejected(ErrorValue.new("Failed to read body: body stream already read", name: "TypeError"))
       end
 
-      @body_used = true
+      # A null body (not an empty one) has nothing to use up.
+      @body_used = true if @has_body
+      @abort_signal&.__internal_remove_abort_algorithm__(@abort_body)
+      return rejected(@body_error) if @body_error
+
       yield
     end
 
+    # Fetch "error response's body" when it is readable: all of a body is
+    # there at once, so it is readable while a nonempty one is unread — an
+    # empty one is already closed, as is a stream read to its end.
+    def abort_body(reason)
+      return if @body_used || !body_readable?
+
+      @body_error = reason
+      @body_stream&.__internal_error__(reason)
+    end
+
+    def body_readable?
+      return false unless @has_body
+
+      @body_stream ? @body_stream.state == :readable : !@body.empty?
+    end
+
     # Lazily build + memoize the body ReadableStream (a single Uint8Array chunk
     # then close), or nil when there is no body.
     def body_stream
@@ -1058,18 +1227,34 @@ module Dommy
         stream = ReadableStream.new(@window)
         stream.__internal_enqueue__(Bridge::Bytes.new(@body.bytes)) unless @body.empty?
         stream.__internal_close__
+        stream.__internal_error__(@body_error) if @body_error
+        follow_abort_through(stream)
         stream
       end
     end
 
+    # A reader can outlive the response, so the abort algorithm also reaches
+    # the stream; a reader taking it to its end leaves the signal nothing to
+    # abort. The stream's callback is the algorithm's own method, not a block
+    # here, which would hold the response for as long as the stream.
+    def follow_abort_through(stream)
+      return unless @abort_body
+
+      @abort_body.stream = stream
+      stream.__internal_when_done__(&@abort_body.method(:release))
+    end
+
     # WHATWG: clone throws if the body is already disturbed/locked; otherwise the
-    # clone is an independent Response over the same bytes.
+    # clone is an independent Response over the same bytes. Its body is a tee
+    # of this one's, so an abort of the fetch errors it too: the clone of a
+    # body already errored is errored, and one made before the abort follows
+    # the same signal.
     def clone_response
       if body_used?
         raise Bridge::TypeError, "Failed to execute 'clone' on 'Response': Response body is already used."
       end
 
-      Response.new(
+      copy = Response.new(
         @window,
         body: @body,
         status: @status,
@@ -1080,6 +1265,12 @@ module Dommy
         type: @type,
         has_body: @has_body
       )
+      if @body_error
+        copy.__internal_abort_body__(@body_error)
+      elsif @abort_signal
+        copy.__internal_follow_abort__(@abort_signal)
+      end
+      copy
     end
 
     # A run of one or more adjacent `\uXXXX` JSON escapes.

data/lib/dommy/file_reader.rb

@@ -9,6 +9,7 @@ module Dommy
   # Spec: https://w3c.github.io/FileAPI/#APIASynch
   class FileReader
     include EventTarget
+    include Internal::WindowBound
     include Internal::EventHandlers::IdlAttributeBridge
 
     EMPTY = 0

data/lib/dommy/form_data.rb

@@ -65,12 +65,17 @@ module Dommy
       copy
     end
 
-    def append(name, value, filename = nil)
+    # A filename left out, as opposed to one given as nil (JS null) or
+    # undefined: WebIDL picks an overload by how many arguments a call passed.
+    NO_FILENAME = Object.new.freeze
+    private_constant :NO_FILENAME
+
+    def append(name, value, filename = NO_FILENAME)
       @pairs << [name.to_s, entry_value(value, filename)]
       nil
     end
 
-    def set(name, value, filename = nil)
+    def set(name, value, filename = NO_FILENAME)
       key = name.to_s
       v = entry_value(value, filename)
       replaced = false
@@ -160,9 +165,9 @@ module Dommy
     def __js_call__(method, args)
       case method
       when "append"
-        append(args[0], args[1], args[2])
+        append(args[0], args[1], args.fetch(2, NO_FILENAME))
       when "set"
-        set(args[0], args[1], args[2])
+        set(args[0], args[1], args.fetch(2, NO_FILENAME))
       when "get"
         get(args[0])
       when "getAll"
@@ -186,14 +191,22 @@ module Dommy
 
     # XHR's "create an entry": a Blob that is not a File becomes a File named
     # "blob", and a File given a filename one of that name, so every file
-    # entry is a File with a name; anything else is a string.
+    # entry is a File with a name; anything else is a string. A call with a
+    # third argument, even undefined, can only be the (name, Blob, filename)
+    # overload, so a string value with one is a TypeError. The filename is
+    # optional: undefined is its absence, null the string "null".
     def entry_value(value, filename)
-      return value.nil? ? "" : value.to_s unless value.is_a?(Blob)
+      unless value.is_a?(Blob)
+        raise Bridge::TypeError, "parameter 2 is not of type 'Blob'." unless filename.equal?(NO_FILENAME)
+
+        return Internal::WebIDL.dom_string(value)
+      end
 
-      filename = nil if filename.equal?(Bridge::UNDEFINED)
-      return value if value.is_a?(File) && filename.nil?
+      return value if value.is_a?(File) && default_filename?(filename)
 
-      value.__internal_file_named__(filename.nil? ? "blob" : filename.to_s)
+      value.__internal_file_named__(default_filename?(filename) ? "blob" : Internal::WebIDL.dom_string(filename))
     end
+
+    def default_filename?(filename) = filename.equal?(NO_FILENAME) || filename.equal?(Bridge::UNDEFINED)
   end
 end

data/lib/dommy/form_entry_list.rb

@@ -7,9 +7,9 @@ module Dommy
   # (Dommy::Interaction::FormSubmission) and `new FormData(form)` build on this,
   # so the two paths collect and fire identically.
   class FormEntryList
-    # @param encoding [Encoding] the submission encoding, used for a
+    # @param encoding [String] the submission encoding's name, used for a
     #   hidden `_charset_`. `new FormData(form)` uses UTF-8.
-    def initialize(form, submitter: nil, encoding: Encoding::UTF_8)
+    def initialize(form, submitter: nil, encoding: "UTF-8")
       @form = form
       @submitter = submitter
       @encoding = encoding
@@ -115,7 +115,7 @@ module Dommy
         collect_file(el, name, data)
       when "hidden"
         # A hidden `_charset_` reports the submission encoding.
-        data.append(name, name.casecmp?("_charset_") ? @encoding.name : el.value.to_s)
+        data.append(name, name.casecmp?("_charset_") ? @encoding : el.value.to_s)
       else
         data.append(name, el.value.to_s)
       end