playwright-ruby-client 0.8.0 → 1.14.beta2

data/lib/playwright/channel_owners/worker.rb

@@ -1,4 +1,27 @@
 module Playwright
   define_channel_owner :Worker do
+    attr_writer :context, :page
+
+    private def after_initialize
+      @channel.once('close', ->(_) { on_close })
+    end
+
+    private def on_close
+      @page&.send(:remove_worker, self)
+      @context&.send(:remove_service_worker, self)
+      emit(Events::Worker::Close, self)
+    end
+
+    def url
+      @initializer['url']
+    end
+
+    def evaluate(expression, arg: nil)
+      JavaScript::Expression.new(expression, arg).evaluate(@channel)
+    end
+
+    def evaluate_handle(expression, arg: nil)
+      JavaScript::Expression.new(expression, arg).evaluate_handle(@channel)
+    end
   end
 end

data/lib/playwright/{download.rb → download_impl.rb}

@@ -1,5 +1,5 @@
 module Playwright
-  class Download
+  define_api_implementation :DownloadImpl do
     def initialize(page:, url:, suggested_filename:, artifact:)
       @page = page
       @url = url
@@ -24,5 +24,9 @@ module Playwright
     def save_as(path)
       @artifact.save_as(path)
     end
+
+    def cancel
+      @artifact.cancel
+    end
   end
 end

data/lib/playwright/javascript/expression.rb

@@ -24,13 +24,14 @@ module Playwright
         ::Playwright::ChannelOwner.from(resp)
       end
 
-      def eval_on_selector(channel, selector)
-        value = channel.send_message_to_server(
-          'evalOnSelector',
+      def eval_on_selector(channel, selector, strict: nil)
+        params = {
           selector: selector,
           expression: @expression,
           arg: @serialized_arg,
-        )
+        }
+        params[:strict] = strict if strict
+        value = channel.send_message_to_server('evalOnSelector', params)
         ValueParser.new(value).parse
       end
 

data/lib/playwright/locator_impl.rb

@@ -0,0 +1,314 @@
+module Playwright
+  define_api_implementation :LocatorImpl do
+    def initialize(frame:, timeout_settings:, selector:)
+      @frame = frame
+      @timeout_settings = timeout_settings
+      @selector = selector
+    end
+
+    def to_s
+      "Locator@#{@selector}"
+    end
+
+    private def with_element(timeout: nil, &block)
+      start_time = Time.now
+
+      handle = @frame.wait_for_selector(@selector, strict: true, state: 'attached', timeout: timeout)
+      unless handle
+        raise "Could not resolve #{@selector} to DOM Element"
+      end
+
+      call_options = {}
+      if timeout
+        call_options[:timeout] = (timeout - (Time.now - start_time) * 1000).to_i
+      end
+
+      begin
+        block.call(handle, call_options)
+      ensure
+        handle.dispose
+      end
+    end
+
+    def bounding_box(timeout: nil)
+      with_element(timeout: timeout) do |handle|
+        handle.bounding_box
+      end
+    end
+
+    def check(
+          force: nil,
+          noWaitAfter: nil,
+          position: nil,
+          timeout: nil,
+          trial: nil)
+
+      @frame.check(@selector,
+        strict: true,
+        force: force,
+        noWaitAfter: noWaitAfter,
+        position: position,
+        timeout: timeout,
+        trial: trial)
+    end
+
+    def click(
+          button: nil,
+          clickCount: nil,
+          delay: nil,
+          force: nil,
+          modifiers: nil,
+          noWaitAfter: nil,
+          position: nil,
+          timeout: nil,
+          trial: nil)
+
+      @frame.click(@selector,
+        strict: true,
+        button: button,
+        clickCount: clickCount,
+        delay: delay,
+        force: force,
+        modifiers: modifiers,
+        noWaitAfter: noWaitAfter,
+        position: position,
+        timeout: timeout,
+        trial: trial)
+    end
+
+    def dblclick(
+          button: nil,
+          delay: nil,
+          force: nil,
+          modifiers: nil,
+          noWaitAfter: nil,
+          position: nil,
+          timeout: nil,
+          trial: nil)
+
+      @frame.dblclick(@selector,
+        strict: true,
+        button: button,
+        delay: delay,
+        force: force,
+        modifiers: modifiers,
+        noWaitAfter: noWaitAfter,
+        position: position,
+        timeout: timeout,
+        trial: trial)
+    end
+
+    def dispatch_event(type, eventInit: nil, timeout: nil)
+      @frame.dispatch_event(@selector, type, strict: true, eventInit: eventInit, timeout: timeout)
+    end
+
+    def evaluate(expression, arg: nil, timeout: nil)
+      with_element(timeout: timeout) do |handle|
+        handle.evaluate(expression, arg: arg)
+      end
+    end
+
+    def evaluate_all(expression, arg: nil)
+      @frame.eval_on_selector_all(@selector, expression, arg: arg)
+    end
+
+    def evaluate_handle(expression, arg: nil, timeout: nil)
+      with_element(timeout: timeout) do |handle|
+        handle.evaluate_handle(expression, arg: arg)
+      end
+    end
+
+    def fill(value, force: nil, noWaitAfter: nil, timeout: nil)
+      @frame.fill(@selector, value, strict: true, force: force, noWaitAfter: noWaitAfter, timeout: timeout)
+    end
+
+    def locator(selector)
+      LocatorImpl.new(
+        frame: @frame,
+        timeout_settings: @timeout_settings,
+        selector: "#{@selector} >> #{selector}",
+      )
+    end
+
+    def element_handle(timeout: nil)
+      @frame.wait_for_selector(@selector, strict: true, state: 'attached', timeout: timeout)
+    end
+
+    def element_handles
+      @frame.query_selector_all(@selector)
+    end
+
+    def first
+      LocatorImpl.new(
+        frame: @frame,
+        timeout_settings: @timeout_settings,
+        selector: "#{@selector} >> _nth=first",
+      )
+    end
+
+    def last
+      LocatorImpl.new(
+        frame: @frame,
+        timeout_settings: @timeout_settings,
+        selector: "#{@selector} >> _nth=last",
+      )
+    end
+
+    def nth(index)
+      LocatorImpl.new(
+        frame: @frame,
+        timeout_settings: @timeout_settings,
+        selector: "#{@selector} >> _nth=#{index}",
+      )
+    end
+
+    def focus(timeout: nil)
+      @frame.focus(@selector, strict: true, timeout: timeout)
+    end
+
+    def count
+      @frame.eval_on_selector_all(@selector, 'ee => ee.length')
+    end
+
+    def get_attribute(name, timeout: nil)
+      @frame.get_attribute(@selector, name, strict: true, timeout: timeout)
+    end
+
+    def hover(
+          force: nil,
+          modifiers: nil,
+          position: nil,
+          timeout: nil,
+          trial: nil)
+      @frame.hover(@selector,
+        strict: true,
+        force: force,
+        modifiers: modifiers,
+        position: position,
+        timeout: timeout,
+        trial: trial)
+    end
+
+    def inner_html(timeout: nil)
+      @frame.inner_html(@selector, strict: true, timeout: timeout)
+    end
+
+    def inner_text(timeout: nil)
+      @frame.inner_text(@selector, strict: true, timeout: timeout)
+    end
+
+    def input_value(timeout: nil)
+      @frame.input_value(@selector, strict: true, timeout: timeout)
+    end
+
+    %i[checked? disabled? editable? enabled? hidden? visible?].each do |method_name|
+      define_method(method_name) do |timeout: nil|
+        @frame.public_send(method_name, @selector, strict: true, timeout: timeout)
+      end
+    end
+
+    def press(key, delay: nil, noWaitAfter: nil, timeout: nil)
+      @frame.press(@selector, key, strict: true, noWaitAfter: noWaitAfter, timeout: timeout)
+    end
+
+    def screenshot(
+          omitBackground: nil,
+          path: nil,
+          quality: nil,
+          timeout: nil,
+          type: nil)
+      with_element(timeout: timeout) do |handle, options|
+        handle.screenshot(
+          omitBackground: omitBackground,
+          path: path,
+          quality: quality,
+          timeout: options[:timeout],
+          type: type)
+      end
+    end
+
+    def scroll_into_view_if_needed(timeout: nil)
+      with_element(timeout: timeout) do |handle, options|
+        handle.scroll_into_view_if_needed(timeout: options[:timeout])
+      end
+    end
+
+    def select_option(
+          element: nil,
+          index: nil,
+          value: nil,
+          label: nil,
+          force: nil,
+          noWaitAfter: nil,
+          timeout: nil)
+
+      @frame.select_option(@selector,
+        strict: true,
+        element: element,
+        index: index,
+        value: value,
+        label: label,
+        force: force,
+        noWaitAfter: noWaitAfter,
+        timeout: timeout)
+    end
+
+    def select_text(force: nil, timeout: nil)
+      with_element(timeout: timeout) do |handle, options|
+        handle.select_text(force: force, timeout: options[:timeout])
+      end
+    end
+
+    def set_input_files(files, noWaitAfter: nil, timeout: nil)
+      @frame.set_input_files(@selector, files, strict: true, noWaitAfter: noWaitAfter, timeout: timeout)
+    end
+
+    def tap_point(
+          force: nil,
+          modifiers: nil,
+          noWaitAfter: nil,
+          position: nil,
+          timeout: nil,
+          trial: nil)
+      @frame.tap_point(@selector,
+        strict: true,
+        force: force,
+        modifiers: modifiers,
+        noWaitAfter: noWaitAfter,
+        position: position,
+        timeout: timeout,
+        trial: trial)
+    end
+
+    def text_content(timeout: nil)
+      @frame.text_content(@selector, strict: true, timeout: timeout)
+    end
+
+    def type(text, delay: nil, noWaitAfter: nil, timeout: nil)
+      @frame.type(@selector, text, strict: true, delay: delay, noWaitAfter: noWaitAfter, timeout: timeout)
+    end
+
+    def uncheck(
+          force: nil,
+          noWaitAfter: nil,
+          position: nil,
+          timeout: nil,
+          trial: nil)
+      @frame.uncheck(@selector,
+        strict: true,
+        force: force,
+        noWaitAfter: noWaitAfter,
+        position: position,
+        timeout: timeout,
+        trial: trial)
+    end
+
+    def all_inner_texts
+      @frame.eval_on_selector_all(@selector, 'ee => ee.map(e => e.innerText)')
+    end
+
+    def all_text_contents
+      @frame.eval_on_selector_all(@selector, "ee => ee.map(e => e.textContent || '')")
+    end
+  end
+end

data/lib/playwright/route_handler_entry.rb

@@ -1,10 +1,11 @@
 module Playwright
   class RouteHandlerEntry
     # @param url [String]
+    # @param base_url [String|nil]
     # @param handler [Proc]
-    def initialize(url, handler)
+    def initialize(url, base_url, handler)
       @url_value = url
-      @url_matcher = UrlMatcher.new(url)
+      @url_matcher = UrlMatcher.new(url, base_url: base_url)
       @handler = handler
     end
 

data/lib/playwright/timeout_settings.rb

@@ -8,12 +8,12 @@ module Playwright
 
     attr_writer :default_timeout, :default_navigation_timeout
 
-    def navigation_timeout
-      @default_navigation_timeout || @default_timeout || @parent&.navigation_timeout || DEFAULT_TIMEOUT
+    def navigation_timeout(timeout_override = nil)
+      timeout_override || @default_navigation_timeout || @default_timeout || @parent&.navigation_timeout || DEFAULT_TIMEOUT
     end
 
-    def timeout
-      @default_timeout || @parent&.timeout || DEFAULT_TIMEOUT
+    def timeout(timeout_override = nil)
+      timeout_override || @default_timeout || @parent&.timeout || DEFAULT_TIMEOUT
     end
   end
 end

data/lib/playwright/touchscreen_impl.rb

@@ -3,5 +3,12 @@ module Playwright
     def initialize(channel)
       @channel = channel
     end
+
+    def tap_point(x, y)
+      @channel.send_message_to_server('touchscreenTap', {
+        x: x,
+        y: y,
+      })
+    end
   end
 end

data/lib/playwright/tracing_impl.rb

@@ -16,16 +16,17 @@ module Playwright
 
     # Stop tracing.
     def stop(path: nil)
+      export(path: path) if path
       @channel.send_message_to_server('tracingStop')
+    end
 
-      if path
-        resp = @channel.send_message_to_server('tracingExport')
-        artifact = ChannelOwners::Artifact.from(resp)
-        # if self._context._browser:
-        #   artifact._is_remote = self._context._browser._is_remote
-        artifact.save_as(path)
-        artifact.delete
-      end
+    private def export(path:)
+      resp = @channel.send_message_to_server('tracingExport')
+      artifact = ChannelOwners::Artifact.from(resp)
+      # if self._context._browser:
+      #   artifact._is_remote = self._context._browser._is_remote
+      artifact.save_as(path)
+      artifact.delete
     end
   end
 end