playwright-ruby-client 0.0.8 → 1.58.1.alpha1

data/lib/playwright_api/tracing.rb

@@ -0,0 +1,128 @@
+module Playwright
+  #
+  # API for collecting and saving Playwright traces. Playwright traces can be opened in [Trace Viewer](../trace-viewer.md) after Playwright script runs.
+  #
+  # **NOTE**: You probably want to [enable tracing in your config file](https://playwright.dev/docs/api/class-testoptions#test-options-trace) instead of using `context.tracing`.
+  #
+  # The `context.tracing` API captures browser operations and network activity, but it doesn't record test assertions (like `expect` calls). We recommend [enabling tracing through Playwright Test configuration](https://playwright.dev/docs/api/class-testoptions#test-options-trace), which includes those assertions and provides a more complete trace for debugging test failures.
+  #
+  # Start recording a trace before performing actions. At the end, stop tracing and save it to a file.
+  #
+  # ```python sync
+  # browser = chromium.launch()
+  # context = browser.new_context()
+  # context.tracing.start(screenshots=True, snapshots=True)
+  # page = context.new_page()
+  # page.goto("https://playwright.dev")
+  # context.tracing.stop(path = "trace.zip")
+  # ```
+  class Tracing < PlaywrightApi
+
+    #
+    # Start tracing.
+    #
+    # **NOTE**: You probably want to [enable tracing in your config file](https://playwright.dev/docs/api/class-testoptions#test-options-trace) instead of using `Tracing.start`.
+    #
+    # The `context.tracing` API captures browser operations and network activity, but it doesn't record test assertions (like `expect` calls). We recommend [enabling tracing through Playwright Test configuration](https://playwright.dev/docs/api/class-testoptions#test-options-trace), which includes those assertions and provides a more complete trace for debugging test failures.
+    #
+    # **Usage**
+    #
+    # ```python sync
+    # context.tracing.start(screenshots=True, snapshots=True)
+    # page = context.new_page()
+    # page.goto("https://playwright.dev")
+    # context.tracing.stop(path = "trace.zip")
+    # ```
+    def start(
+          name: nil,
+          screenshots: nil,
+          snapshots: nil,
+          sources: nil,
+          title: nil)
+      wrap_impl(@impl.start(name: unwrap_impl(name), screenshots: unwrap_impl(screenshots), snapshots: unwrap_impl(snapshots), sources: unwrap_impl(sources), title: unwrap_impl(title)))
+    end
+
+    #
+    # Start a new trace chunk. If you'd like to record multiple traces on the same `BrowserContext`, use [`method: Tracing.start`] once, and then create multiple trace chunks with [`method: Tracing.startChunk`] and [`method: Tracing.stopChunk`].
+    #
+    # **Usage**
+    #
+    # ```python sync
+    # context.tracing.start(screenshots=True, snapshots=True)
+    # page = context.new_page()
+    # page.goto("https://playwright.dev")
+    #
+    # context.tracing.start_chunk()
+    # page.get_by_text("Get Started").click()
+    # # Everything between start_chunk and stop_chunk will be recorded in the trace.
+    # context.tracing.stop_chunk(path = "trace1.zip")
+    #
+    # context.tracing.start_chunk()
+    # page.goto("http://example.com")
+    # # Save a second trace file with different actions.
+    # context.tracing.stop_chunk(path = "trace2.zip")
+    # ```
+    def start_chunk(name: nil, title: nil)
+      wrap_impl(@impl.start_chunk(name: unwrap_impl(name), title: unwrap_impl(title)))
+    end
+
+    #
+    # **NOTE**: Use `test.step` instead when available.
+    #
+    # Creates a new group within the trace, assigning any subsequent API calls to this group, until [`method: Tracing.groupEnd`] is called. Groups can be nested and will be visible in the trace viewer.
+    #
+    # **Usage**
+    #
+    # ```python sync
+    # # All actions between group and group_end
+    # # will be shown in the trace viewer as a group.
+    # page.context.tracing.group("Open Playwright.dev > API")
+    # page.goto("https://playwright.dev/")
+    # page.get_by_role("link", name="API").click()
+    # page.context.tracing.group_end()
+    # ```
+    def group(name, location: nil)
+      wrap_impl(@impl.group(unwrap_impl(name), location: unwrap_impl(location)))
+    end
+
+    #
+    # Closes the last group created by [`method: Tracing.group`].
+    def group_end
+      wrap_impl(@impl.group_end)
+    end
+
+    #
+    # Stop tracing.
+    def stop(path: nil)
+      wrap_impl(@impl.stop(path: unwrap_impl(path)))
+    end
+
+    #
+    # Stop the trace chunk. See [`method: Tracing.startChunk`] for more details about multiple trace chunks.
+    def stop_chunk(path: nil)
+      wrap_impl(@impl.stop_chunk(path: unwrap_impl(path)))
+    end
+
+    # -- inherited from EventEmitter --
+    # @nodoc
+    def once(event, callback)
+      event_emitter_proxy.once(event, callback)
+    end
+
+    # -- inherited from EventEmitter --
+    # @nodoc
+    def on(event, callback)
+      event_emitter_proxy.on(event, callback)
+    end
+
+    # -- inherited from EventEmitter --
+    # @nodoc
+    def off(event, callback)
+      event_emitter_proxy.off(event, callback)
+    end
+
+    private def event_emitter_proxy
+      @event_emitter_proxy ||= EventEmitterProxy.new(self, @impl)
+    end
+  end
+end

data/lib/playwright_api/web_socket.rb

@@ -1,21 +1,59 @@
 module Playwright
-  # The `WebSocket` class represents websocket connections in the page.
+  #
+  # The `WebSocket` class represents WebSocket connections within a page. It provides the ability to inspect and manipulate the data being transmitted and received.
+  #
+  # If you want to intercept or modify WebSocket frames, consider using `WebSocketRoute`.
   class WebSocket < PlaywrightApi
 
+    #
     # Indicates that the web socket has been closed.
     def closed?
-      raise NotImplementedError.new('closed? is not implemented yet.')
+      wrap_impl(@impl.closed?)
     end
 
+    #
     # Contains the URL of the WebSocket.
     def url
-      raise NotImplementedError.new('url is not implemented yet.')
+      wrap_impl(@impl.url)
     end
 
+    #
     # Waits for event to fire and passes its value into the predicate function. Returns when the predicate returns truthy
     # value. Will throw an error if the webSocket is closed before the event is fired. Returns the event data value.
-    def expect_event(event, optionsOrPredicate: nil)
-      raise NotImplementedError.new('expect_event is not implemented yet.')
+    def expect_event(event, predicate: nil, timeout: nil, &block)
+      wrap_impl(@impl.expect_event(unwrap_impl(event), predicate: unwrap_impl(predicate), timeout: unwrap_impl(timeout), &wrap_block_call(block)))
+    end
+
+    #
+    # **NOTE**: In most cases, you should use [`method: WebSocket.waitForEvent`].
+    #
+    # Waits for given `event` to fire. If predicate is provided, it passes
+    # event's value into the `predicate` function and waits for `predicate(event)` to return a truthy value.
+    # Will throw an error if the socket is closed before the `event` is fired.
+    def wait_for_event(event, predicate: nil, timeout: nil, &block)
+      wrap_impl(@impl.wait_for_event(unwrap_impl(event), predicate: unwrap_impl(predicate), timeout: unwrap_impl(timeout), &wrap_block_call(block)))
+    end
+
+    # -- inherited from EventEmitter --
+    # @nodoc
+    def once(event, callback)
+      event_emitter_proxy.once(event, callback)
+    end
+
+    # -- inherited from EventEmitter --
+    # @nodoc
+    def on(event, callback)
+      event_emitter_proxy.on(event, callback)
+    end
+
+    # -- inherited from EventEmitter --
+    # @nodoc
+    def off(event, callback)
+      event_emitter_proxy.off(event, callback)
+    end
+
+    private def event_emitter_proxy
+      @event_emitter_proxy ||= EventEmitterProxy.new(self, @impl)
     end
   end
 end

data/lib/playwright_api/worker.rb

@@ -1,58 +1,98 @@
 module Playwright
+  #
   # The Worker class represents a [WebWorker](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API). `worker`
   # event is emitted on the page object to signal a worker creation. `close` event is emitted on the worker object when the
   # worker is gone.
-  # 
   #
-  # ```js
-  # page.on('worker', worker => {
-  #   console.log('Worker created: ' + worker.url());
-  #   worker.on('close', worker => console.log('Worker destroyed: ' + worker.url()));
-  # });
-  # 
-  # console.log('Current workers:');
-  # for (const worker of page.workers())
-  #   console.log('  ' + worker.url());
-  # ```
-  # 
   # ```py
   # def handle_worker(worker):
   #     print("worker created: " + worker.url)
   #     worker.on("close", lambda: print("worker destroyed: " + worker.url))
-  # 
+  #
   # page.on('worker', handle_worker)
-  # 
+  #
   # print("current workers:")
   # for worker in page.workers:
   #     print("    " + worker.url)
   # ```
   class Worker < PlaywrightApi
 
-    # Returns the return value of `pageFunction`
-    # 
-    # If the function passed to the `worker.evaluate` returns a [Promise], then `worker.evaluate` would wait for the promise
+    #
+    # Returns the return value of `expression`.
+    #
+    # If the function passed to the [`method: Worker.evaluate`] returns a [Promise], then [`method: Worker.evaluate`] would wait for the promise
     # to resolve and return its value.
-    # 
-    # If the function passed to the `worker.evaluate` returns a non-[Serializable] value, then `worker.evaluate` returns
-    # `undefined`. DevTools Protocol also supports transferring some additional values that are not serializable by `JSON`:
-    # `-0`, `NaN`, `Infinity`, `-Infinity`, and bigint literals.
-    def evaluate(pageFunction, arg: nil)
-      raise NotImplementedError.new('evaluate is not implemented yet.')
-    end
-
-    # Returns the return value of `pageFunction` as in-page object (JSHandle).
-    # 
-    # The only difference between `worker.evaluate` and `worker.evaluateHandle` is that `worker.evaluateHandle` returns
-    # in-page object (JSHandle).
-    # 
-    # If the function passed to the `worker.evaluateHandle` returns a [Promise], then `worker.evaluateHandle` would wait for
+    #
+    # If the function passed to the [`method: Worker.evaluate`] returns a non-[Serializable] value, then [`method: Worker.evaluate`] returns `undefined`. Playwright also supports transferring some
+    # additional values that are not serializable by `JSON`: `-0`, `NaN`, `Infinity`, `-Infinity`.
+    def evaluate(expression, arg: nil)
+      wrap_impl(@impl.evaluate(unwrap_impl(expression), arg: unwrap_impl(arg)))
+    end
+
+    #
+    # Returns the return value of `expression` as a `JSHandle`.
+    #
+    # The only difference between [`method: Worker.evaluate`] and
+    # [`method: Worker.evaluateHandle`] is that [`method: Worker.evaluateHandle`]
+    # returns `JSHandle`.
+    #
+    # If the function passed to the [`method: Worker.evaluateHandle`] returns a [Promise], then [`method: Worker.evaluateHandle`] would wait for
     # the promise to resolve and return its value.
-    def evaluate_handle(pageFunction, arg: nil)
-      raise NotImplementedError.new('evaluate_handle is not implemented yet.')
+    def evaluate_handle(expression, arg: nil)
+      wrap_impl(@impl.evaluate_handle(unwrap_impl(expression), arg: unwrap_impl(arg)))
     end
 
     def url
-      raise NotImplementedError.new('url is not implemented yet.')
+      wrap_impl(@impl.url)
+    end
+
+    #
+    # Waits for event to fire and passes its value into the predicate function.
+    # Returns when the predicate returns truthy value.
+    # Will throw an error if the page is closed before the event is fired.
+    # Returns the event data value.
+    #
+    # **Usage**
+    #
+    # ```python sync
+    # with worker.expect_event("console") as event_info:
+    #     worker.evaluate("console.log(42)")
+    # message = event_info.value
+    # ```
+    def expect_event(event, predicate: nil, timeout: nil, &block)
+      wrap_impl(@impl.expect_event(unwrap_impl(event), predicate: unwrap_impl(predicate), timeout: unwrap_impl(timeout), &wrap_block_call(block)))
+    end
+
+    # @nodoc
+    def page=(req)
+      wrap_impl(@impl.page=(unwrap_impl(req)))
+    end
+
+    # @nodoc
+    def context=(req)
+      wrap_impl(@impl.context=(unwrap_impl(req)))
+    end
+
+    # -- inherited from EventEmitter --
+    # @nodoc
+    def once(event, callback)
+      event_emitter_proxy.once(event, callback)
+    end
+
+    # -- inherited from EventEmitter --
+    # @nodoc
+    def on(event, callback)
+      event_emitter_proxy.on(event, callback)
+    end
+
+    # -- inherited from EventEmitter --
+    # @nodoc
+    def off(event, callback)
+      event_emitter_proxy.off(event, callback)
+    end
+
+    private def event_emitter_proxy
+      @event_emitter_proxy ||= EventEmitterProxy.new(self, @impl)
     end
   end
 end

data/playwright.gemspec

@@ -11,28 +11,33 @@ Gem::Specification.new do |spec|
   spec.authors       = ['YusukeIwaki']
   spec.email         = ['q7w8e9w8q7w8e9@yahoo.co.jp']
 
-  spec.summary       = 'The Ruby binding of playwright driver'
+  spec.summary       = "The Ruby binding of playwright driver #{Playwright::COMPATIBLE_PLAYWRIGHT_VERSION}"
   spec.homepage      = 'https://github.com/YusukeIwaki/playwright-ruby-client'
   spec.license       = 'MIT'
 
   spec.files         = Dir.chdir(File.expand_path(__dir__)) do
     `git ls-files -z`.split("\x0").reject do |f|
-      f.match(%r{^(test|spec|features)/}) || f.include?(".git") || f.start_with?("development/")
+      f.match(%r{^(test|spec|features)/}) || f.include?(".git") || f.include?(".circleci") || f.start_with?("development/")
     end
-  end + `find lib/playwright_api -name *.rb -type f`.split("\n")
+  end + `find lib/playwright_api -name *.rb -type f`.split("\n") + `find sig -name *.rbs -type f`.split("\n")
   spec.bindir        = 'exe'
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']
 
-  spec.add_dependency 'concurrent-ruby'
+  spec.required_ruby_version = '>= 2.4'
+  spec.add_dependency 'base64'
+  spec.add_dependency 'concurrent-ruby', '>= 1.1.6'
   spec.add_dependency 'mime-types', '>= 3.0'
-  spec.add_development_dependency 'bundler', '~> 2.2.3'
+  spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'chunky_png'
   spec.add_development_dependency 'dry-inflector'
+  spec.add_development_dependency 'faye-websocket'
   spec.add_development_dependency 'pry-byebug'
-  spec.add_development_dependency 'rake', '~> 13.0.3'
-  spec.add_development_dependency 'rspec', '~> 3.10.0 '
-  spec.add_development_dependency 'rubocop', '~> 1.7.0'
+  spec.add_development_dependency 'ostruct'
+  spec.add_development_dependency 'puma'
+  spec.add_development_dependency 'rack', '< 3'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec'
   spec.add_development_dependency 'rubocop-rspec'
   spec.add_development_dependency 'sinatra'
-  spec.add_development_dependency 'webrick'
 end