dommy 0.15.0 → 0.16.0

data/lib/dommy/browser.rb

@@ -71,21 +71,50 @@ module Dommy
       @console = []
       @disposed = false
       @pending_navigations = []
+      @popups = []
       @runtime = nil
+      # One browsing session: every window it shows (and their frames) shares
+      # localStorage per origin and sessionStorage per origin.
+      @storage_provider = StorageProvider.new
+      # One cookie store for the session: document.cookie, cookieStore, and
+      # the Cookie / Set-Cookie of every request it sends through resources.
+      @cookie_jar = CookieJar.new
+      @before_unload_handler = nil
 
       @window = Dommy.parse(html)
       @window.location.__internal_set_url__(url) if url
-      install_runtime(@window)
+      @window.storage_provider = @storage_provider
+      @window.cookie_jar = @cookie_jar
 
       if navigable
-        @fetcher = Navigation::Fetcher.new(@resources, same_origin: @same_origin)
+        @fetcher = navigation_fetcher
         @history = Navigation::JointHistory.new
         @window.navigation_delegate = self
         @history.push(current_url, window: @window, windex: @window.history.__internal_index__)
+        install_history_sync(@window)
       end
+      install_runtime(@window)
       check_js_errors!
     end
 
+    # The provider of this browser's Web Storage areas (shared by every window
+    # it shows); see Dommy::StorageProvider.
+    attr_reader :storage_provider
+
+    # This browser's cookies (a Dommy::CookieJar): the one store its pages'
+    # document.cookie and cookieStore use and its requests send and fill.
+    attr_reader :cookie_jar
+
+    # Install a handler for a page that asks to confirm leaving it (a canceled
+    # `beforeunload`, or one whose returnValue is set): called with the window
+    # and the BeforeUnloadEvent, its truthy answer lets the navigation proceed.
+    # Without one the navigation always proceeds — a headless page has no sticky
+    # user activation, so a browser would not prompt either.
+    def on_before_unload(&block)
+      @before_unload_handler = block
+      self
+    end
+
     def document = @window.document
 
     # Current document HTML (serialized).
@@ -117,8 +146,8 @@ module Dommy
     # Move back / forward one entry in the joint history. A same-document target
     # (the entry's window is still live) traverses in place (popstate); a
     # document-boundary target is re-fetched (no bfcache — D2).
-    def back = traverse(-1)
-    def forward = traverse(1)
+    def back = traverse_now(-1)
+    def forward = traverse_now(1)
 
     # --- NavigationDelegate port (see Dommy::Navigation) ---
 
@@ -138,7 +167,7 @@ module Dommy
         navigate_frame(frame,
           {method: method, url: url, params: params, body: body, enctype: enctype, headers: headers},
           resolve_against_current(url.to_s))
-        @window.scheduler.queue_microtask(proc { frame.dispatch_event(Dommy::Event.new("load")) })
+        @window.scheduler.queue_microtask(proc { frame.__internal_run_iframe_load_event_steps__ })
         return nil
       end
 
@@ -164,6 +193,109 @@ module Dommy
       end
 
       def traverse(_delta) = nil
+
+      def history_length = @browser.history_length
+
+      # The frames of the document loaded into this frame load the same way.
+      def load_frame(frame, **nav) = @browser.load_frame(frame, **nav)
+
+      # A popup opened from inside the frame is the browser's too.
+      def open_window(**opts) = @browser.open_window(**opts)
+    end
+
+    # The navigation delegate of an auxiliary window this browser opened
+    # (window.open): its navigations load into it, keeping the Window the
+    # opener holds (Dommy has no WindowProxy, so the document is swapped
+    # under it), and its close() closes it.
+    class PopupDelegate
+      def initialize(browser, popup)
+        @browser = browser
+        @popup = popup
+      end
+
+      def navigate(url:, source:, method: "GET", body: nil, params: nil, enctype: nil, target: nil, headers: {}, replace: false)
+        @browser.__internal_load_popup__(@popup, {url: url, method: method, body: body, params: params,
+                                                  enctype: enctype, headers: headers})
+      end
+
+      def traverse(_delta) = nil
+
+      def close_window = @browser.__internal_close_popup__(@popup)
+
+      def find_window(name) = @browser.find_window(name)
+
+      def load_frame(frame, **nav) = @browser.load_frame(frame, **nav)
+
+      def open_window(**opts) = @browser.open_window(**opts)
+    end
+
+    # The auxiliary windows the page opened with window.open and has not
+    # closed, oldest first.
+    def popups = @popups.dup
+
+    # NavigationDelegate `open_window`: window.open asked for a new top-level
+    # browsing context. It is created at once with the initial about:blank
+    # (whose origin is the opener's) and navigated to `url` from a task; it
+    # shares this browser's cookies and localStorage, and starts its
+    # sessionStorage as a copy of this one's. Window#window_open sets its
+    # opener and name.
+    def open_window(url:, target:, features: "")
+      return nil if @disposed
+
+      popup = Dommy.parse(Internal::ChildNavigable::BLANK_HTML)
+      popup.location.__internal_set_url__("about:blank")
+      popup.__internal_initial_about_blank__ = true
+      popup.storage_provider = @storage_provider.new_session
+      popup.cookie_jar = @cookie_jar
+      popup.navigation_delegate = PopupDelegate.new(self, popup)
+      @popups << popup
+      unless Internal::ChildNavigable.matches_about_blank?(url)
+        @window.scheduler.set_timeout(proc { __internal_load_popup__(popup, {url: url, method: "GET"}) }, 0)
+      end
+      popup
+    end
+
+    # Load a navigation into a popup: fetch it, give the popup's Window the
+    # document, and fire its load. Nothing happens when nothing serves it.
+    def __internal_load_popup__(popup, nav)
+      return nil if @disposed || @resources.nil? || !@popups.include?(popup)
+
+      url = nav[:url].to_s
+      @fetcher ||= navigation_fetcher
+      response, final_url = begin
+        @fetcher.request(method: nav[:method] || "GET", url: url, params: nav[:params],
+                         body: nav[:body], enctype: nav[:enctype], headers: nav[:headers] || {})
+      rescue StandardError
+        [nil, url]
+      end
+      return nil unless response && document_response?(response)
+
+      loaded = Internal::ChildNavigable.window_for_response(response.body, response_header(response, "content-type"), final_url)
+      popup.__internal_adopt_document_of__(loaded)
+      popup.navigation_delegate = PopupDelegate.new(self, popup)
+      document = popup.document
+      document.__internal_update_readiness__("loading")
+      document.__internal_finish_loading__
+      nil
+    end
+
+    # NavigationDelegate `find_window`: the top-level window (this browser's
+    # page or a popup) or a frame in one, whose target name is `name`.
+    def find_window(name)
+      ([@window] + @popups).each do |top|
+        return top if top.name == name
+
+        found = top.__internal_find_descendant_window__(name)
+        return found if found
+      end
+      nil
+    end
+
+    # A popup's close(): it leaves the browser, closed.
+    def __internal_close_popup__(popup)
+      @popups.delete(popup)
+      popup.__internal_discard__
+      nil
     end
 
     def frame_navigation_delegate(frame) = FrameNavigationDelegate.new(self, frame)
@@ -179,26 +311,49 @@ module Dommy
         nav[:url].to_s
       end
       navigate_frame(frame, nav, resolved)
-      frame.dispatch_event(Dommy::Event.new("load"))
+      frame.__internal_run_iframe_load_event_steps__
       nil
     end
 
-    # A cross-document history traversal. Ruby-initiated (back / forward), so it
-    # runs immediately: a same-document target (its window is still live)
-    # traverses in place (popstate); a document-boundary target is re-fetched.
+    # NavigationDelegate `load_frame`: an iframe's child navigable is navigating
+    # to `url` (its `src`, or a navigation from inside it) — fetch it through
+    # this browser's resources and answer the document's Window, or nil when
+    # nothing serves it (the frame then keeps its document). The frame installs
+    # it and fires its own `load`.
+    def load_frame(frame, url:, method: "GET", body: nil, params: nil, enctype: nil, headers: {}, **)
+      return nil if @disposed || @resources.nil?
+
+      frame_window_for(frame, {url: url, method: method, body: body, params: params, enctype: enctype, headers: headers}, url.to_s)
+    end
+
+    # A history traversal by `delta` that the PAGE asked for (`history.go(n)`
+    # past its own document's entries): like a navigation it is a task, so it
+    # is recorded and performed at the next drain boundary.
     def traverse(delta)
-      return self unless @navigable
+      @pending_navigations << {traverse: delta.to_i} if @navigable
+      nil
+    end
 
-      entry = delta.negative? ? @history.back : @history.forward
-      return self unless entry
+    # `history.length`: the joint session history's size (nil when this
+    # browser keeps none).
+    def history_length = (@history.length if @navigable)
 
-      if entry.window && entry.window.equal?(@window)
-        @window.history.__internal_go_to__(entry.windex)
-        @runtime.drain_microtasks
-        check_js_errors!
-      else
-        perform_navigation!({url: entry.url, method: "GET", source: :traverse}, rebind: true)
-      end
+    # `window.stop()`: drop the navigations the page asked for and that have not
+    # been performed yet.
+    def stop
+      @pending_navigations.clear
+      nil
+    end
+
+    # A Ruby-initiated traversal (back / forward) runs immediately: a
+    # same-document target (its window is still live) traverses in place
+    # (popstate); a document-boundary target is re-fetched.
+    def traverse_now(delta)
+      return self unless @navigable
+
+      perform_traversal!(delta)
+      @runtime.drain_microtasks
+      check_js_errors!
       self
     end
 
@@ -221,6 +376,7 @@ module Dommy
     # `setTimeout(300)` — use `advance_time(300)` for debounce/throttle.
     def settle
       @runtime.settle
+      drive_popups(0)
       flush_navigation!
       check_js_errors!
       self
@@ -229,6 +385,7 @@ module Dommy
     # Advance virtual time by `ms`, running timers that come due, then settle.
     def advance_time(ms)
       @window.scheduler.advance_time(ms)
+      drive_popups(ms)
       @runtime.drain_microtasks
       flush_navigation!
       check_js_errors!
@@ -240,6 +397,7 @@ module Dommy
     # land before the next line, then enforce strict mode.
     def after_interaction
       @runtime.drain_microtasks
+      drive_popups(0)
       flush_navigation!
       check_js_errors!
     end
@@ -319,7 +477,10 @@ module Dommy
       # Opt-in WPT scaffolding (common/sab.js derives SharedArrayBuffer through
       # WebAssembly.Memory); off by default so real pages don't see the shim.
       runtime.install_wasm_memory_shim if @wasm_memory_shim && runtime.respond_to?(:install_wasm_memory_shim)
-      window.globals["__fetch_handler__"] = Resources::FetchHandler.new(@resources) if @resources
+      if @resources
+        window.globals["__fetch_handler__"] =
+          Resources::FetchHandler.new(@resources, cookie_jar: @cookie_jar, origin: -> { window.origin })
+      end
       @runtime = runtime
       doc = window.document
       # An `on*` attribute that arrived after boot (a cloned template, an
@@ -327,7 +488,7 @@ module Dommy
       # Installed whenever a runtime is attached — an embedder that drives script
       # boot itself (`execute_scripts: false`) still needs inline handlers wired.
       doc.inline_handler_wirer = lambda do
-        Js::ScriptBoot.wire_inline_handlers(runtime, on_error: ->(e) { @error_log.record(e) })
+        Js::ScriptBoot.wire_inline_handlers(runtime, document: doc, on_error: ->(e) { @error_log.record(e) })
       end
       return unless @execute_scripts
 
@@ -348,6 +509,16 @@ module Dommy
       runtime.settle if @settle_after_boot
     end
 
+    # A popup has no realm of its own; the tasks queued on its window (a
+    # close(), its timers) run as the browser's time moves.
+    def drive_popups(ms)
+      @popups.dup.each { |popup| popup.scheduler.advance_time(ms) }
+    end
+
+    def navigation_fetcher
+      Navigation::Fetcher.new(@resources, same_origin: @same_origin, cookie_jar: @cookie_jar)
+    end
+
     # Route an unhandled promise rejection through the page's own
     # `unhandledrejection` handling first. The engine decides WHEN a rejection
     # counts as unhandled (see Window#__internal_report_rejection__).
@@ -371,22 +542,31 @@ module Dommy
       frame = resolve_target_frame(nav[:target])
       return navigate_frame(frame, nav, resolved) if frame
 
+      # The outgoing page may ask to confirm leaving (beforeunload).
+      return unless unloading_allowed?(@window)
+
       response, final_url = @fetcher.request(
         method: nav[:method] || "GET", url: resolved, params: nav[:params],
         body: nav[:body], enctype: nav[:enctype], headers: nav[:headers] || {}
       )
       return unless response&.success? && document_response?(response)
 
+      old_window = @window
+      referrer = referrer_for(nav[:source], old_window.location.href, final_url)
       # Fire the outgoing document's unload sequence while its realm is still
       # alive, then surface any of its errors before the realm is torn down.
-      fire_unload(@window)
+      fire_unload(old_window)
       check_js_errors!
 
-      new_window = Dommy.parse(response.body)
+      new_window = Dommy.parse(Encodings.decode_document(response.body, response_header(response, "content-type")))
       new_window.location.__internal_set_url__(final_url)
+      new_window.document.__internal_set_last_modified__(response_header(response, "last-modified"))
+      new_window.document.__internal_referrer__ = referrer if referrer
       new_window.navigation_delegate = self
+      new_window.storage_provider = @storage_provider
+      new_window.cookie_jar = @cookie_jar
+      old_window.__internal_discard__
       @window = new_window
-      install_runtime(new_window)
 
       windex = new_window.history.__internal_index__
       if rebind || nav[:replace]
@@ -394,10 +574,82 @@ module Dommy
       else
         @history.push(final_url, window: new_window, windex: windex)
       end
+      # The joint history knows the new page before its scripts boot, so a
+      # pushState / history.length during boot sees the right session.
+      install_history_sync(new_window)
+      install_runtime(new_window)
 
       follow_meta_refresh!(refresh_depth)
     end
 
+    # Fire `beforeunload` at the outgoing window; a page that cancels it (or
+    # sets returnValue) is asked about through the on_before_unload handler, if
+    # one is installed.
+    def unloading_allowed?(window)
+      event = BeforeUnloadEvent.new("beforeunload", "cancelable" => true).__internal_mark_trusted__
+      not_canceled = window.dispatch_event(event)
+      return true if not_canceled && event.return_value.to_s.empty?
+      return true unless @before_unload_handler
+
+      @before_unload_handler.call(window, event) ? true : false
+    end
+
+    # The `document.referrer` a navigation hands the new document: the page
+    # that started it (links, forms, script), under the default
+    # strict-origin-when-cross-origin policy — the full URL (without fragment
+    # or credentials) within an origin, only the origin across origins, nothing
+    # on an https -> http downgrade. Ruby-initiated visits and traversals carry
+    # none.
+    def referrer_for(source, from_url, to_url)
+      return nil unless %i[link form location window_open].include?(source)
+
+      from = URL.new(from_url.to_s)
+      to = URL.new(to_url.to_s)
+      return nil unless %w[http: https:].include?(from.protocol)
+      return "" if from.protocol == "https:" && to.protocol == "http:"
+      return "#{from.origin}/" unless from.origin == to.origin
+
+      from.hash = ""
+      from.username = ""
+      from.password = ""
+      from.href
+    rescue StandardError
+      nil
+    end
+
+    # A traversal by `delta` of the joint history: within the live window's own
+    # entries it moves that window's history (popstate); across a document
+    # boundary the target entry's URL is re-fetched (no bfcache).
+    def perform_traversal!(delta)
+      entry = @history.go(delta)
+      return unless entry
+
+      if entry.window && entry.window.equal?(@window)
+        @window.history.__internal_go_to__(entry.windex)
+      else
+        perform_navigation!({url: entry.url, method: "GET", source: :traverse}, rebind: true)
+      end
+    end
+
+    # Mirror the page's same-document history changes (pushState, fragment
+    # navigations, its own back/forward within the document) into the joint
+    # history, so Browser#back and history.length see them. Guarded against a
+    # navigated-away window.
+    def install_history_sync(window)
+      window.history.__internal_on_change__ = lambda do |kind, url|
+        next unless window.equal?(@window)
+
+        case kind
+        when :push
+          @history.push(url, window: window, windex: window.history.__internal_index__)
+        when :replace
+          @history.rebind_current(url: url, window: window, windex: window.history.__internal_index__)
+        when :traverse
+          @history.sync_to(window, window.history.__internal_index__)
+        end
+      end
+    end
+
     # The reserved browsing-context keywords; anything else names an iframe.
     RESERVED_TARGETS = %w[_self _top _parent _blank].freeze
 
@@ -417,32 +669,43 @@ module Dommy
     # it, install the response document as the frame's content, and fire the
     # frame's `load`. The top-level window and joint history are left alone.
     def navigate_frame(frame, nav, resolved_url)
-      response, final_url = @fetcher.request(
-        method: nav[:method] || "GET", url: resolved_url, params: nav[:params],
-        body: nav[:body], enctype: nav[:enctype], headers: nav[:headers] || {}
-      )
-      return unless response&.success?
+      # The frame makes about:, data: and blob: documents itself and asks
+      # this browser (#load_frame) for the rest.
+      sub_window = frame.__internal_child_document_for__(resolved_url, nil, nav.except(:url))
+      return nil unless sub_window
 
-      sub_window = frame_document_for(response)
-      sub_window.location.__internal_set_url__(final_url)
       # A navigation from inside the loaded frame also stays in that frame.
-      sub_window.navigation_delegate = frame_navigation_delegate(frame)
-      # A nested realm needs the seeded constructors to run the response's
-      # scripts; a runtime that cannot expose them simply runs without them.
-      @runtime.expose_constructors_on(sub_window) if @runtime.respond_to?(:expose_constructors_on)
+      sub_window.navigation_delegate = frame_navigation_delegate(frame) if sub_window.navigation_delegate.is_a?(Navigation::NullDelegate)
       frame.__internal_set_content_document__(sub_window.document)
       nil
     end
 
-    # The document a frame shows for a response: HTML/XML is parsed as-is; a
-    # non-document response (e.g. text/plain from an echo endpoint) is displayed
-    # as text, so the frame gets a document whose body holds it.
-    def frame_document_for(response)
-      return Dommy.parse(response.body) if document_response?(response)
+    # Fetch a frame navigation and build the Window of the document it
+    # answers. nil when nothing (successful) serves the URL.
+    def frame_window_for(frame, nav, resolved_url)
+      @fetcher ||= navigation_fetcher
+      response, final_url = begin
+        @fetcher.request(
+          method: nav[:method] || "GET", url: resolved_url, params: nav[:params],
+          body: nav[:body], enctype: nav[:enctype], headers: nav[:headers] || {}
+        )
+      rescue StandardError
+        # A resources adapter that cannot serve the request at all fails the
+        # navigation like a network error.
+        [nil, resolved_url]
+      end
+      # Nothing answered: a network error, which shows an error page (and
+      # still fires the frame's load). A response of any status is a document.
+      return Internal::ChildNavigable.error_window(final_url || resolved_url) unless response
 
-      win = Dommy.parse("<!doctype html><html><head></head><body></body></html>")
-      win.document.body.text_content = response.body.to_s.dup.force_encoding(Encoding::UTF_8)
-      win
+      sub_window = Internal::ChildNavigable.window_for_response(
+        response.body, response_header(response, "content-type"), final_url
+      )
+      sub_window.document.__internal_set_last_modified__(response_header(response, "last-modified"))
+      # A nested realm needs the seeded constructors to run the response's
+      # scripts; a runtime that cannot expose them simply runs without them.
+      @runtime.expose_constructors_on(sub_window) if @runtime.respond_to?(:expose_constructors_on)
+      sub_window
     end
 
     # If the freshly loaded document asks for an immediate `<meta http-equiv=
@@ -489,24 +752,36 @@ module Dommy
 
       navs = @pending_navigations
       @pending_navigations = []
-      navs.each { |nav| perform_navigation!(nav) }
+      navs.each do |nav|
+        nav.key?(:traverse) ? perform_traversal!(nav[:traverse]) : perform_navigation!(nav)
+      end
     end
 
+    # Unload the outgoing document: `pagehide` (a PageTransitionEvent, persisted
+    # false), then `unload` — both trusted and targeted at the document.
     def fire_unload(window)
-      window.dispatch_event(Dommy::Event.new("pagehide"))
-      window.dispatch_event(Dommy::Event.new("unload"))
+      document = window.document
+      window.dispatch_event(document.__internal_page_transition_event__("pagehide"))
+      unload = Dommy::Event.new("unload")
+      unload.__internal_set_target__(document)
+      window.dispatch_event(unload.__internal_mark_trusted__)
     end
 
     # Only HTML/XML responses replace the document; other content types (a JSON
     # API hit, an image) leave the current page. A response with no Content-Type
     # is treated as a document (fixtures commonly omit it).
     def document_response?(response)
-      headers = response.headers || {}
-      key = headers.keys.find { |k| k.to_s.casecmp?("content-type") }
-      content_type = key ? headers[key].to_s.downcase : ""
+      content_type = response_header(response, "content-type").to_s.downcase
       content_type.empty? || content_type.include?("html") || content_type.include?("xml")
     end
 
+    # A response header's value by case-insensitive name, or nil.
+    def response_header(response, name)
+      headers = response.headers || {}
+      key = headers.keys.find { |k| k.to_s.casecmp?(name) }
+      key && headers[key]
+    end
+
     def submit_button?(button)
       if button.tag_name == "BUTTON"
         button.type == "submit"

data/lib/dommy/character_data.rb

@@ -89,9 +89,10 @@ module Dommy
       @__node__.content
     end
 
+    # Assigning `data`, `nodeValue` or `textContent` is "replace data" over
+    # the whole node, so a live range boundary inside it clamps to the start
+    # rather than dangling past the end.
     def data=(value)
-      # Assigning `data` is "replace data" over the whole node, so a live range
-      # boundary inside it clamps to the start rather than dangling past the end.
       old_length = utf16_length(@__node__.content)
       write_data(value)
       @document.__internal_ranges_replaced_data__(self, 0, old_length, utf16_length(@__node__.content))
@@ -102,7 +103,7 @@ module Dommy
     end
 
     def node_value=(value)
-      write_data(value)
+      self.data = value
     end
 
     def text_content
@@ -110,9 +111,16 @@ module Dommy
     end
 
     def text_content=(value)
-      write_data(value)
+      self.data = value
+    end
+
+    # Node.isConnected: whether the shadow-including root is a Document.
+    def is_connected?
+      Internal::NodeTraversal.connected?(@__node__, @document)
     end
 
+    alias connected? is_connected?
+
     def remove
       @document.remove_node_with_notify(@__node__)
       nil
@@ -178,29 +186,13 @@ module Dommy
     def substring_data(offset, count)
       s = @__node__.content
       len = utf16_length(s)
-      o = to_uint32(offset)
+      o = Internal::WebIDL.unsigned_long(offset)
       raise DOMException::IndexSizeError, "offset out of bounds" if o > len
 
-      c = [to_uint32(count), len - o].min
+      c = [Internal::WebIDL.unsigned_long(count), len - o].min
       utf16_slice(s, o, c)
     end
 
-    # ECMAScript ToUint32 — WebIDL `unsigned long` conversion for a data offset
-    # or count: ToNumber (a non-numeric string is NaN), truncate toward zero,
-    # then take modulo 2**32 (so -1 wraps to 4294967295, 0x100000000+2 to 2).
-    def to_uint32(value)
-      num =
-        case value
-        when Integer then value
-        when Numeric then value
-        when nil then 0 # JS null -> 0
-        else Float(value.to_s) rescue Float::NAN
-        end
-      return 0 unless num.respond_to?(:finite?) ? num.finite? : true
-
-      num.to_i % (2**32)
-    end
-
     def append_data(value)
       write_data(@__node__.content + dom_string(value))
     end
@@ -222,10 +214,10 @@ module Dommy
     def replace_data(offset, count, value)
       s = @__node__.content
       len = utf16_length(s)
-      o = to_uint32(offset)
+      o = Internal::WebIDL.unsigned_long(offset)
       raise DOMException::IndexSizeError, "offset out of bounds" if o > len
 
-      c = [to_uint32(count), len - o].min
+      c = [Internal::WebIDL.unsigned_long(count), len - o].min
       inserted = dom_string(value)
       write_data(utf16_slice(s, 0, o) + inserted + utf16_slice(s, o + c, len - (o + c)))
       # Live ranges whose boundary sits in (or past) the replaced run follow it.
@@ -256,6 +248,8 @@ module Dommy
         next_sibling
       when "previousSibling"
         previous_sibling
+      when "isConnected"
+        is_connected?
       when "childNodes"
         # CharacterData is a leaf node: childNodes is always an empty (but
         # present and iterable) NodeList, and firstChild/lastChild are null.
@@ -293,7 +287,7 @@ module Dommy
     def __js_set__(key, value)
       case key
       when "textContent", "data", "nodeValue"
-        write_data(value)
+        self.data = value
       end
 
       nil
@@ -312,8 +306,7 @@ module Dommy
         false
       when "contains"
         # A leaf node contains only itself (no descendants).
-        args[0].respond_to?(:__dommy_backend_node__) &&
-          args[0].__dommy_backend_node__ == @__node__
+        args[0].is_a?(Node) && args[0].__dommy_backend_node__ == @__node__
       when "appendChild"
         append_child(args[0])
       when "insertBefore"