playwright-ruby-client 0.0.3 → 0.0.8

data/lib/playwright/javascript/value_serializer.rb

@@ -0,0 +1,54 @@
+module Playwright
+  module JavaScript
+    class ValueSerializer
+      def initialize(ruby_value)
+        @value = ruby_value
+      end
+
+      # @return [Hash]
+      def serialize
+        @handles = []
+        { value: serialize_value(@value), handles: @handles }
+      end
+
+      # ref: https://github.com/microsoft/playwright/blob/b45905ae3f1a066a8ecb358035ce745ddd21cf3a/src/protocol/serializers.ts#L84
+      # ref: https://github.com/microsoft/playwright-python/blob/25a99d53e00e35365cf5113b9525272628c0e65f/playwright/_impl/_js_handle.py#L99
+      private def serialize_value(value)
+        case value
+        when ChannelOwners::JSHandle
+          index = @handles.count
+          @handles << value.channel
+          { h: index }
+        when nil
+          { v: 'undefined' }
+        when Float::NAN
+          { v: 'NaN'}
+        when Float::INFINITY
+          { v: 'Infinity' }
+        when -Float::INFINITY
+          { v: '-Infinity' }
+        when true, false
+          { b: value }
+        when Numeric
+          { n: value }
+        when String
+          { s: value }
+        when Time
+          require 'time'
+          { d: value.utc.iso8601 }
+        when Regexp
+          flags = []
+          flags << 'ms' if (value.options & Regexp::MULTILINE) != 0
+          flags << 'i' if (value.options & Regexp::IGNORECASE) != 0
+          { r: { p: value.source, f: flags.join('') } }
+        when Array
+          { a: value.map { |v| serialize_value(v) } }
+        when Hash
+          { o: value.map { |key, v| { k: key, v: serialize_value(v) } } }
+        else
+          raise ArgumentError.new("Unexpected value: #{value}")
+        end
+      end
+    end
+  end
+end

data/lib/playwright/playwright_api.rb

@@ -7,66 +7,86 @@ module Playwright
     # @param channel_owner [ChannelOwner]
     # @note Intended for internal use only.
     def self.from_channel_owner(channel_owner)
-      Factory.new(channel_owner).create
+      Factory.new(channel_owner, 'ChannelOwners').create
     end
 
-    private
-
     class Factory
-      def initialize(channel_owner)
-        channel_owner_class_name = channel_owner.class.name
-        raise "#{channel_owner_class_name} is not a channel owner" unless channel_owner_class_name.include?('::ChannelOwners::')
+      def initialize(impl, module_name)
+        impl_class_name = impl.class.name
+        unless impl_class_name.include?("::#{module_name}::")
+          raise "#{impl_class_name} is not #{module_name}"
+        end
 
-        @channel_owner = channel_owner
+        @impl = impl
+        @module_name = module_name
       end
 
       def create
-        api_class = detect_class_for(@channel_owner.class)
+        api_class = detect_class_for(@impl.class)
         if api_class
-          api_class.new(@channel_owner)
+          api_class.new(@impl)
         else
-          raise NotImplementedError.new("Playwright::#{expected_class_name_for(@channel_owner.class)} is not implemented")
+          raise NotImplementedError.new("Playwright::#{expected_class_name_for(@impl.class)} is not implemented")
         end
       end
 
       private
 
       def expected_class_name_for(klass)
-        klass.name.split('::ChannelOwners::').last
+        klass.name.split("::#{@module_name}::").last
+      end
+
+      def superclass_exist?(klass)
+        ![::Playwright::ChannelOwner, ::Playwright::InputType, Object].include?(klass.superclass)
       end
 
       def detect_class_for(klass)
         class_name = expected_class_name_for(klass)
         if ::Playwright.const_defined?(class_name)
           ::Playwright.const_get(class_name)
+        elsif superclass_exist?(klass)
+          detect_class_for(klass.superclass)
         else
-          if [::Playwright::ChannelOwner, Object].include?(klass.superclass)
-            nil
-          else
-            detect_class_for(klass.superclass)
-          end
+          nil
         end
       end
     end
 
-    # @param channel_owner [Playwright::ChannelOwner]
-    def initialize(channel_owner)
-      @channel_owner = channel_owner
+    # @param impl [Playwright::ChannelOwner|Playwright::InputType]
+    def initialize(impl)
+      @impl = impl
+    end
+
+    def ==(other)
+      @impl.to_s == other.instance_variable_get(:'@impl').to_s
     end
 
     # @param block [Proc]
-    def wrap_block_call(block)
+    private def wrap_block_call(block)
+      return nil unless block.is_a?(Proc)
+
       -> (*args) {
-        wrapped_args = args.map { |arg| wrap_channel_owner(arg) }
+        wrapped_args = args.map { |arg| wrap_impl(arg) }
         block.call(*wrapped_args)
       }
     end
 
-    def wrap_channel_owner(object)
-      if object.is_a?(ChannelOwner)
+    private def wrap_impl(object)
+      case object
+      when ChannelOwner
         PlaywrightApi.from_channel_owner(object)
-      elsif object.is_a?(Array)
-        object.map { |obj| wrap_channel_owner(obj) }
+      when InputType
+        Factory.new(object, 'InputTypes').create
+      when Array
+        object.map { |obj| wrap_impl(obj) }
+      else
+        object
+      end
+    end
+
+    private def unwrap_impl(object)
+      if object.is_a?(PlaywrightApi)
+        object.instance_variable_get(:@impl)
       else
         object
       end

data/lib/playwright/select_option_values.rb

@@ -0,0 +1,32 @@
+module Playwright
+  class SelectOptionValues
+    def initialize(values)
+      @params = convert(values)
+    end
+
+    # @return [Hash]
+    def as_params
+      @params
+    end
+
+    private def convert(values)
+      return {} unless values
+      return convert([values]) unless values.is_a?('Array')
+      return {} if values.empty?
+      values.each_with_index do |value, index|
+        unless values
+          raise ArgumentError.new("options[#{index}]: expected object, got null")
+        end
+      end
+
+      case values.first
+      when ElementHandle
+        { elements: values.map(&:channel) }
+      when String
+        { options: values.map { |value| { value: value } } }
+      else
+        { options: values }
+      end
+    end
+  end
+end

data/lib/playwright/timeout_settings.rb

@@ -0,0 +1,19 @@
+module Playwright
+  class TimeoutSettings
+    DEFAULT_TIMEOUT = 30000
+
+    def initialize(parent = nil)
+      @parent = parent
+    end
+
+    attr_writer :default_timeout, :default_navigation_timeout
+
+    def navigation_timeout
+      @default_navigation_timeout || @default_timeout || @parent&.navigation_timeout || DEFAULT_TIMEOUT
+    end
+
+    def timeout
+      @default_timeout || @parent&.timeout || DEFAULT_TIMEOUT
+    end
+  end
+end

data/lib/playwright/url_matcher.rb

@@ -0,0 +1,19 @@
+module Playwright
+  class UrlMatcher
+    # @param url [String|Regexp]
+    def initialize(url)
+      @url = url
+    end
+
+    def match?(target_url)
+      case @url
+      when String
+        @url == target_url
+      when Regexp
+        @url.match?(target_url)
+      else
+        false
+      end
+    end
+  end
+end

data/lib/playwright/utils.rb

@@ -0,0 +1,37 @@
+module Playwright
+  module Utils
+    module PrepareBrowserContextOptions
+      # @see https://github.com/microsoft/playwright/blob/5a2cfdbd47ed3c3deff77bb73e5fac34241f649d/src/client/browserContext.ts#L265
+      private def prepare_browser_context_options(params)
+        if params[:viewport] == 0
+          params.delete(:viewport)
+          params[:noDefaultViewport] = true
+        end
+        if params[:extraHTTPHeaders]
+          # TODO
+        end
+        if params[:storageState].is_a?(String)
+          params[:storageState] = JSON.parse(File.read(params[:storageState]))
+        end
+
+        params
+      end
+    end
+
+    module Errors
+      module SafeCloseError
+        # @param err [Exception]
+        private def safe_close_error?(err)
+          return true if err.is_a?(Transport::AlreadyDisconnectedError)
+
+          [
+            'Browser has been closed',
+            'Target page, context or browser has been closed',
+          ].any? do |closed_message|
+            err.message.end_with?(closed_message)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/playwright/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Playwright
-  VERSION = '0.0.3'
+  VERSION = '0.0.8'
 end

data/lib/playwright/wait_helper.rb

@@ -0,0 +1,73 @@
+module Playwright
+  # ref: https://github.com/microsoft/playwright-python/blob/30946ae3099d51f9b7f355f9ae7e8c04d748ce36/playwright/_impl/_wait_helper.py
+  # ref: https://github.com/microsoft/playwright/blob/01fb3a6045cbdb4b5bcba0809faed85bd917ab87/src/client/waiter.ts#L21
+  class WaitHelper
+    def initialize
+      @promise = Concurrent::Promises.resolvable_future
+      @registered_listeners = Set.new
+    end
+
+    def reject_on_event(emitter, event, error, predicate: nil)
+      listener = -> (*args) {
+        if !predicate || predicate.call(*args)
+          reject(error)
+        end
+      }
+      emitter.on(event, listener)
+      @registered_listeners << [emitter, event, listener]
+
+      self
+    end
+
+    def reject_on_timeout(timeout_ms, message)
+      return if timeout_ms <= 0
+
+      Concurrent::Promises.schedule(timeout_ms / 1000.0) {
+        reject(TimeoutError.new(message))
+      }
+
+      self
+    end
+
+    # @param [Playwright::EventEmitter]
+    # @param
+    def wait_for_event(emitter, event, predicate: nil)
+      listener = -> (*args) {
+        begin
+          if !predicate || predicate.call(*args)
+            fulfill(*args)
+          end
+        rescue => err
+          reject(err)
+        end
+      }
+      emitter.on(event, listener)
+      @registered_listeners << [emitter, event, listener]
+
+      self
+    end
+
+    attr_reader :promise
+
+    private def cleanup
+      @registered_listeners.each do |emitter, event, listener|
+        emitter.off(event, listener)
+      end
+      @registered_listeners.clear
+    end
+
+    private def fulfill(*args)
+      cleanup
+      unless @promise.resolved?
+        @promise.fulfill(args.first)
+      end
+    end
+
+    private def reject(error)
+      cleanup
+      unless @promise.resolved?
+        @promise.reject(error)
+      end
+    end
+  end
+end

data/lib/playwright_api/accessibility.rb

@@ -1,21 +1,45 @@
 module Playwright
-  # The Accessibility class provides methods for inspecting Chromium's accessibility tree. The accessibility tree is used by assistive technology such as screen readers or switches.
-  # Accessibility is a very platform-specific thing. On different platforms, there are different screen readers that might have wildly different output.
-  # Blink - Chromium's rendering engine - has a concept of "accessibility tree", which is then translated into different platform-specific APIs. Accessibility namespace gives users access to the Blink Accessibility Tree.
-  # Most of the accessibility tree gets filtered out when converting from Blink AX Tree to Platform-specific AX-Tree or by assistive technologies themselves. By default, Playwright tries to approximate this filtering, exposing only the "interesting" nodes of the tree.
+  # The Accessibility class provides methods for inspecting Chromium's accessibility tree. The accessibility tree is used by
+  # assistive technology such as [screen readers](https://en.wikipedia.org/wiki/Screen_reader) or
+  # [switches](https://en.wikipedia.org/wiki/Switch_access).
+  # 
+  # Accessibility is a very platform-specific thing. On different platforms, there are different screen readers that might
+  # have wildly different output.
+  # 
+  # Rendering engines of Chromium, Firefox and Webkit have a concept of "accessibility tree", which is then translated into
+  # different platform-specific APIs. Accessibility namespace gives access to this Accessibility Tree.
+  # 
+  # Most of the accessibility tree gets filtered out when converting from internal browser AX Tree to Platform-specific
+  # AX-Tree or by assistive technologies themselves. By default, Playwright tries to approximate this filtering, exposing
+  # only the "interesting" nodes of the tree.
   class Accessibility < PlaywrightApi
 
-    # Captures the current state of the accessibility tree. The returned object represents the root accessible node of the page.
+    # Captures the current state of the accessibility tree. The returned object represents the root accessible node of the
+    # page.
     # 
-    # **NOTE** The Chromium accessibility tree contains nodes that go unused on most platforms and by most screen readers. Playwright will discard them as well for an easier to process tree, unless `interestingOnly` is set to `false`.
+    # > NOTE: The Chromium accessibility tree contains nodes that go unused on most platforms and by most screen readers.
+    # Playwright will discard them as well for an easier to process tree, unless `interestingOnly` is set to `false`.
     # 
     # An example of dumping the entire accessibility tree:
+    # 
     #
     # ```js
     # const snapshot = await page.accessibility.snapshot();
     # console.log(snapshot);
     # ```
+    # 
+    # ```python async
+    # snapshot = await page.accessibility.snapshot()
+    # print(snapshot)
+    # ```
+    # 
+    # ```python sync
+    # snapshot = page.accessibility.snapshot()
+    # print(snapshot)
+    # ```
+    # 
     # An example of logging the focused node's name:
+    # 
     #
     # ```js
     # const snapshot = await page.accessibility.snapshot();
@@ -32,6 +56,36 @@ module Playwright
     #   return null;
     # }
     # ```
+    # 
+    # ```python async
+    # def find_focused_node(node):
+    #     if (node.get("focused"))
+    #         return node
+    #     for child in (node.get("children") or []):
+    #         found_node = find_focused_node(child)
+    #         return found_node
+    #     return None
+    # 
+    # snapshot = await page.accessibility.snapshot()
+    # node = find_focused_node(snapshot)
+    # if node:
+    #     print(node["name"])
+    # ```
+    # 
+    # ```python sync
+    # def find_focused_node(node):
+    #     if (node.get("focused"))
+    #         return node
+    #     for child in (node.get("children") or []):
+    #         found_node = find_focused_node(child)
+    #         return found_node
+    #     return None
+    # 
+    # snapshot = page.accessibility.snapshot()
+    # node = find_focused_node(snapshot)
+    # if node:
+    #     print(node["name"])
+    # ```
     def snapshot(interestingOnly: nil, root: nil)
       raise NotImplementedError.new('snapshot is not implemented yet.')
     end