playwright-ruby-client 0.0.5 → 0.0.6

data/lib/playwright/input_type.rb

@@ -0,0 +1,19 @@
+module Playwright
+  class InputType
+    def initialize(channel)
+      @channel = channel
+    end
+  end
+
+  # namespace declaration
+  module InputTypes ; end
+
+  def self.define_input_type(class_name, &block)
+    klass = Class.new(InputType)
+    klass.class_eval(&block) if block
+    InputTypes.const_set(class_name, klass)
+  end
+end
+
+# load subclasses
+Dir[File.join(__dir__, 'input_types', '*.rb')].each { |f| require f }

data/lib/playwright/input_types/keyboard.rb

@@ -0,0 +1,32 @@
+module Playwright
+  define_input_type :Keyboard do
+    def down(key)
+      @channel.send_message_to_server('keyboardDown', key: key)
+      nil
+    end
+
+    def up(key)
+      @channel.send_message_to_server('keyboardDown', key: key)
+    end
+
+    def insert_text(text)
+      @channel.send_message_to_server('keyboardInsertText', text: text)
+    end
+
+    def type_text(text, delay: nil)
+      params = {
+        text: text,
+        delay: delay,
+      }.compact
+      @channel.send_message_to_server('keyboardType', params)
+    end
+
+    def press(key, delay: nil)
+      params = {
+        key: key,
+        delay: delay,
+      }.compact
+      @channel.send_message_to_server('keyboardPress', params)
+    end
+  end
+end

data/lib/playwright/input_types/mouse.rb

@@ -0,0 +1,4 @@
+module Playwright
+  define_input_type :Mouse do
+  end
+end

data/lib/playwright/input_types/touchscreen.rb

@@ -0,0 +1,4 @@
+module Playwright
+  define_input_type :Touchscreen do
+  end
+end

data/lib/playwright/javascript/expression.rb

@@ -25,6 +25,28 @@ module Playwright
         )
         ::Playwright::ChannelOwner.from(resp)
       end
+
+      def eval_on_selector(channel, selector)
+        value = channel.send_message_to_server(
+          'evalOnSelector',
+          selector: selector,
+          expression: @expression,
+          isFunction: false,
+          arg: @serialized_arg,
+        )
+        ValueParser.new(value).parse
+      end
+
+      def eval_on_selector_all(channel, selector)
+        value = channel.send_message_to_server(
+          'evalOnSelectorAll',
+          selector: selector,
+          expression: @expression,
+          isFunction: false,
+          arg: @serialized_arg,
+        )
+        ValueParser.new(value).parse
+      end
     end
   end
 end

data/lib/playwright/javascript/function.rb

@@ -25,6 +25,28 @@ module Playwright
         )
         ::Playwright::ChannelOwner.from(resp)
       end
+
+      def eval_on_selector(channel, selector)
+        value = channel.send_message_to_server(
+          'evalOnSelector',
+          selector: selector,
+          expression: @definition,
+          isFunction: true,
+          arg: @serialized_arg,
+        )
+        ValueParser.new(value).parse
+      end
+
+      def eval_on_selector_all(channel, selector)
+        value = channel.send_message_to_server(
+          'evalOnSelectorAll',
+          selector: selector,
+          expression: @definition,
+          isFunction: true,
+          arg: @serialized_arg,
+        )
+        ValueParser.new(value).parse
+      end
     end
   end
 end

data/lib/playwright/playwright_api.rb

@@ -7,53 +7,58 @@ 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
 
     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)
-      @channel_owner.to_s == other.instance_variable_get(:'@channel_owner').to_s
+      @impl.to_s == other.instance_variable_get(:'@impl').to_s
     end
 
     # @param block [Proc]
@@ -61,16 +66,19 @@ module Playwright
       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
 
-    private 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

data/lib/playwright/timeout_settings.rb

@@ -9,7 +9,7 @@ module Playwright
     attr_writer :default_timeout, :default_navigation_timeout
 
     def navigation_timeout
-      @default_navigation_timeout || @default_timeout || @parent&.navigation_timeout || EFAULT_TIMEOUT
+      @default_navigation_timeout || @default_timeout || @parent&.navigation_timeout || DEFAULT_TIMEOUT
     end
 
     def timeout

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/version.rb

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

data/lib/playwright_api/accessibility.rb

@@ -6,18 +6,18 @@ module Playwright
   # 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.
+  # 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 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.
+  # 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.
     # 
-    # > **NOTE** The Chromium accessibility tree contains nodes that go unused on most platforms and by most screen readers.
+    # > 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:
@@ -28,6 +28,16 @@ module Playwright
     # 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:
     # 
     #
@@ -46,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

data/lib/playwright_api/binding_call.rb

@@ -4,20 +4,20 @@ module Playwright
 
     # -- inherited from EventEmitter --
     # @nodoc
-    def off(event, callback)
-      wrap_channel_owner(@channel_owner.off(event, callback))
+    def on(event, callback)
+      wrap_impl(@impl.on(event, callback))
     end
 
     # -- inherited from EventEmitter --
     # @nodoc
-    def once(event, callback)
-      wrap_channel_owner(@channel_owner.once(event, callback))
+    def off(event, callback)
+      wrap_impl(@impl.off(event, callback))
     end
 
     # -- inherited from EventEmitter --
     # @nodoc
-    def on(event, callback)
-      wrap_channel_owner(@channel_owner.on(event, callback))
+    def once(event, callback)
+      wrap_impl(@impl.once(event, callback))
     end
   end
 end

data/lib/playwright_api/browser.rb

@@ -1,5 +1,5 @@
 module Playwright
-  # - extends: [EventEmitter](https://nodejs.org/api/events.html#events_class_eventemitter)
+  # - extends: [EventEmitter]
   # 
   # A Browser is created via [`method: BrowserType.launch`]. An example of using a `Browser` to create a [Page]:
   # 
@@ -15,8 +15,36 @@ module Playwright
   # })();
   # ```
   # 
-  # See `ChromiumBrowser`, [FirefoxBrowser] and [WebKitBrowser] for browser-specific features. Note that
-  # [`method: BrowserType.launch`] always returns a specific browser instance, based on the browser being launched.
+  # ```python async
+  # import asyncio
+  # from playwright.async_api import async_playwright
+  # 
+  # async def run(playwright):
+  #     firefox = playwright.firefox
+  #     browser = await firefox.launch()
+  #     page = await browser.new_page()
+  #     await page.goto("https://example.com")
+  #     await browser.close()
+  # 
+  # async def main():
+  #     async with async_playwright() as playwright:
+  #         await run(playwright)
+  # asyncio.run(main())
+  # ```
+  # 
+  # ```python sync
+  # from playwright.sync_api import sync_playwright
+  # 
+  # def run(playwright):
+  #     firefox = playwright.firefox
+  #     browser = firefox.launch()
+  #     page = browser.new_page()
+  #     page.goto("https://example.com")
+  #     browser.close()
+  # 
+  # with sync_playwright() as playwright:
+  #     run(playwright)
+  # ```
   class Browser < PlaywrightApi
 
     # In case this browser is obtained using [`method: BrowserType.launch`], closes the browser and all of its pages (if any
@@ -27,7 +55,7 @@ module Playwright
     # 
     # The `Browser` object itself is considered to be disposed and cannot be used anymore.
     def close
-      wrap_channel_owner(@channel_owner.close)
+      wrap_impl(@impl.close)
     end
 
     # Returns an array of all open browser contexts. In a newly created browser, this will return zero browser contexts.
@@ -40,13 +68,27 @@ module Playwright
     # const context = await browser.newContext();
     # console.log(browser.contexts().length); // prints `1`
     # ```
+    # 
+    # ```python async
+    # browser = await pw.webkit.launch()
+    # print(len(browser.contexts())) # prints `0`
+    # context = await browser.new_context()
+    # print(len(browser.contexts())) # prints `1`
+    # ```
+    # 
+    # ```python sync
+    # browser = pw.webkit.launch()
+    # print(len(browser.contexts())) # prints `0`
+    # context = browser.new_context()
+    # print(len(browser.contexts())) # prints `1`
+    # ```
     def contexts
-      wrap_channel_owner(@channel_owner.contexts)
+      wrap_impl(@impl.contexts)
     end
 
     # Indicates that the browser is connected.
     def connected?
-      wrap_channel_owner(@channel_owner.connected?)
+      wrap_impl(@impl.connected?)
     end
 
     # Creates a new browser context. It won't share cookies/cache with other browser contexts.
@@ -62,6 +104,24 @@ module Playwright
     #   await page.goto('https://example.com');
     # })();
     # ```
+    # 
+    # ```python async
+    # browser = await playwright.firefox.launch() # or "chromium" or "webkit".
+    # # create a new incognito browser context.
+    # context = await browser.new_context()
+    # # create a new page in a pristine context.
+    # page = await context.new_page()
+    # await page.goto("https://example.com")
+    # ```
+    # 
+    # ```python sync
+    # browser = playwright.firefox.launch() # or "chromium" or "webkit".
+    # # create a new incognito browser context.
+    # context = browser.new_context()
+    # # create a new page in a pristine context.
+    # page = context.new_page()
+    # page.goto("https://example.com")
+    # ```
     def new_context(
           acceptDownloads: nil,
           bypassCSP: nil,
@@ -87,7 +147,7 @@ module Playwright
           videoSize: nil,
           videosPath: nil,
           viewport: nil)
-      wrap_channel_owner(@channel_owner.new_context(acceptDownloads: acceptDownloads, bypassCSP: bypassCSP, colorScheme: colorScheme, deviceScaleFactor: deviceScaleFactor, extraHTTPHeaders: extraHTTPHeaders, geolocation: geolocation, hasTouch: hasTouch, httpCredentials: httpCredentials, ignoreHTTPSErrors: ignoreHTTPSErrors, isMobile: isMobile, javaScriptEnabled: javaScriptEnabled, locale: locale, logger: logger, offline: offline, permissions: permissions, proxy: proxy, recordHar: recordHar, recordVideo: recordVideo, storageState: storageState, timezoneId: timezoneId, userAgent: userAgent, videoSize: videoSize, videosPath: videosPath, viewport: viewport))
+      wrap_impl(@impl.new_context(acceptDownloads: acceptDownloads, bypassCSP: bypassCSP, colorScheme: colorScheme, deviceScaleFactor: deviceScaleFactor, extraHTTPHeaders: extraHTTPHeaders, geolocation: geolocation, hasTouch: hasTouch, httpCredentials: httpCredentials, ignoreHTTPSErrors: ignoreHTTPSErrors, isMobile: isMobile, javaScriptEnabled: javaScriptEnabled, locale: locale, logger: logger, offline: offline, permissions: permissions, proxy: proxy, recordHar: recordHar, recordVideo: recordVideo, storageState: storageState, timezoneId: timezoneId, userAgent: userAgent, videoSize: videoSize, videosPath: videosPath, viewport: viewport))
     end
 
     # Creates a new page in a new browser context. Closing this page will close the context as well.
@@ -120,35 +180,35 @@ module Playwright
           videoSize: nil,
           videosPath: nil,
           viewport: nil)
-      wrap_channel_owner(@channel_owner.new_page(acceptDownloads: acceptDownloads, bypassCSP: bypassCSP, colorScheme: colorScheme, deviceScaleFactor: deviceScaleFactor, extraHTTPHeaders: extraHTTPHeaders, geolocation: geolocation, hasTouch: hasTouch, httpCredentials: httpCredentials, ignoreHTTPSErrors: ignoreHTTPSErrors, isMobile: isMobile, javaScriptEnabled: javaScriptEnabled, locale: locale, logger: logger, offline: offline, permissions: permissions, proxy: proxy, recordHar: recordHar, recordVideo: recordVideo, storageState: storageState, timezoneId: timezoneId, userAgent: userAgent, videoSize: videoSize, videosPath: videosPath, viewport: viewport))
+      wrap_impl(@impl.new_page(acceptDownloads: acceptDownloads, bypassCSP: bypassCSP, colorScheme: colorScheme, deviceScaleFactor: deviceScaleFactor, extraHTTPHeaders: extraHTTPHeaders, geolocation: geolocation, hasTouch: hasTouch, httpCredentials: httpCredentials, ignoreHTTPSErrors: ignoreHTTPSErrors, isMobile: isMobile, javaScriptEnabled: javaScriptEnabled, locale: locale, logger: logger, offline: offline, permissions: permissions, proxy: proxy, recordHar: recordHar, recordVideo: recordVideo, storageState: storageState, timezoneId: timezoneId, userAgent: userAgent, videoSize: videoSize, videosPath: videosPath, viewport: viewport))
     end
 
     # Returns the browser version.
     def version
-      wrap_channel_owner(@channel_owner.version)
+      wrap_impl(@impl.version)
     end
 
     # @nodoc
     def after_initialize
-      wrap_channel_owner(@channel_owner.after_initialize)
+      wrap_impl(@impl.after_initialize)
     end
 
     # -- inherited from EventEmitter --
     # @nodoc
-    def off(event, callback)
-      wrap_channel_owner(@channel_owner.off(event, callback))
+    def on(event, callback)
+      wrap_impl(@impl.on(event, callback))
     end
 
     # -- inherited from EventEmitter --
     # @nodoc
-    def once(event, callback)
-      wrap_channel_owner(@channel_owner.once(event, callback))
+    def off(event, callback)
+      wrap_impl(@impl.off(event, callback))
     end
 
     # -- inherited from EventEmitter --
     # @nodoc
-    def on(event, callback)
-      wrap_channel_owner(@channel_owner.on(event, callback))
+    def once(event, callback)
+      wrap_impl(@impl.once(event, callback))
     end
   end
 end