playwright-ruby-client 0.0.3

data/lib/playwright_api/playwright.rb

@@ -0,0 +1,35 @@
+module Playwright
+  # @nodoc
+  class Playwright < PlaywrightApi
+
+    # @nodoc
+    def android
+      wrap_channel_owner(@channel_owner.android)
+    end
+
+    # @nodoc
+    def chromium
+      wrap_channel_owner(@channel_owner.chromium)
+    end
+
+    # @nodoc
+    def electron
+      wrap_channel_owner(@channel_owner.electron)
+    end
+
+    # @nodoc
+    def firefox
+      wrap_channel_owner(@channel_owner.firefox)
+    end
+
+    # @nodoc
+    def devices
+      wrap_channel_owner(@channel_owner.devices)
+    end
+
+    # @nodoc
+    def webkit
+      wrap_channel_owner(@channel_owner.webkit)
+    end
+  end
+end

data/lib/playwright_api/request.rb

@@ -0,0 +1,119 @@
+module Playwright
+  # Whenever the page sends a request for a network resource the following sequence of events are emitted by Page:
+  # 
+  # page.on('request') emitted when the request is issued by the page.
+  # page.on('response') emitted when/if the response status and headers are received for the request.
+  # page.on('requestfinished') emitted when the response body is downloaded and the request is complete.
+  # 
+  # If request fails at some point, then instead of `'requestfinished'` event (and possibly instead of 'response' event), the  page.on('requestfailed') event is emitted.
+  # 
+  # **NOTE** HTTP Error responses, such as 404 or 503, are still successful responses from HTTP standpoint, so request will complete with `'requestfinished'` event.
+  # 
+  # If request gets a 'redirect' response, the request is successfully finished with the 'requestfinished' event, and a new request is  issued to a redirected url.
+  class Request < PlaywrightApi
+
+    # The method returns `null` unless this request has failed, as reported by `requestfailed` event.
+    # Example of logging of all the failed requests:
+    #
+    # ```js
+    # page.on('requestfailed', request => {
+    #   console.log(request.url() + ' ' + request.failure().errorText);
+    # });
+    # ```
+    def failure
+      raise NotImplementedError.new('failure is not implemented yet.')
+    end
+
+    # Returns the Frame that initiated this request.
+    def frame
+      raise NotImplementedError.new('frame is not implemented yet.')
+    end
+
+    # An object with HTTP headers associated with the request. All header names are lower-case.
+    def headers
+      raise NotImplementedError.new('headers is not implemented yet.')
+    end
+
+    # Whether this request is driving frame's navigation.
+    def navigation_request?
+      raise NotImplementedError.new('navigation_request? is not implemented yet.')
+    end
+
+    # Request's method (GET, POST, etc.)
+    def method
+      wrap_channel_owner(@channel_owner.method)
+    end
+
+    # Request's post body, if any.
+    def post_data
+      raise NotImplementedError.new('post_data is not implemented yet.')
+    end
+
+    # Request's post body in a binary form, if any.
+    def post_data_buffer
+      raise NotImplementedError.new('post_data_buffer is not implemented yet.')
+    end
+
+    # Returns parsed request's body for `form-urlencoded` and JSON as a fallback if any.
+    # When the response is `application/x-www-form-urlencoded` then a key/value object of the values will be returned. Otherwise it will be parsed as JSON.
+    def post_data_json
+      raise NotImplementedError.new('post_data_json is not implemented yet.')
+    end
+
+    # Request that was redirected by the server to this one, if any.
+    # When the server responds with a redirect, Playwright creates a new Request object. The two requests are connected by `redirectedFrom()` and `redirectedTo()` methods. When multiple server redirects has happened, it is possible to construct the whole redirect chain by repeatedly calling `redirectedFrom()`.
+    # For example, if the website `http://example.com` redirects to `https://example.com`:
+    #
+    # ```js
+    # const response = await page.goto('http://example.com');
+    # console.log(response.request().redirectedFrom().url()); // 'http://example.com'
+    # ```
+    # If the website `https://google.com` has no redirects:
+    #
+    # ```js
+    # const response = await page.goto('https://google.com');
+    # console.log(response.request().redirectedFrom()); // null
+    # ```
+    def redirected_from
+      raise NotImplementedError.new('redirected_from is not implemented yet.')
+    end
+
+    # New request issued by the browser if the server responded with redirect.
+    # This method is the opposite of `request.redirectedFrom()`:
+    #
+    # ```js
+    # console.log(request.redirectedFrom().redirectedTo() === request); // true
+    # ```
+    def redirected_to
+      raise NotImplementedError.new('redirected_to is not implemented yet.')
+    end
+
+    # Contains the request's resource type as it was perceived by the rendering engine. ResourceType will be one of the following: `document`, `stylesheet`, `image`, `media`, `font`, `script`, `texttrack`, `xhr`, `fetch`, `eventsource`, `websocket`, `manifest`, `other`.
+    def resource_type
+      raise NotImplementedError.new('resource_type is not implemented yet.')
+    end
+
+    # Returns the matching Response object, or `null` if the response was not received due to error.
+    def response
+      raise NotImplementedError.new('response is not implemented yet.')
+    end
+
+    # Returns resource timing information for given request. Most of the timing values become available upon the response, `responseEnd` becomes available when request finishes. Find more information at Resource Timing API.
+    #
+    # ```js
+    # const [request] = await Promise.all([
+    #   page.waitForEvent('requestfinished'),
+    #   page.goto(httpsServer.EMPTY_PAGE)
+    # ]);
+    # console.log(request.timing());
+    # ```
+    def timing
+      raise NotImplementedError.new('timing is not implemented yet.')
+    end
+
+    # URL of the request.
+    def url
+      raise NotImplementedError.new('url is not implemented yet.')
+    end
+  end
+end

data/lib/playwright_api/response.rb

@@ -0,0 +1,61 @@
+module Playwright
+  # Response class represents responses which are received by page.
+  class Response < PlaywrightApi
+
+    # Returns the buffer with response body.
+    def body
+      raise NotImplementedError.new('body is not implemented yet.')
+    end
+
+    # Waits for this response to finish, returns failure error if request failed.
+    def finished
+      raise NotImplementedError.new('finished is not implemented yet.')
+    end
+
+    # Returns the Frame that initiated this response.
+    def frame
+      raise NotImplementedError.new('frame is not implemented yet.')
+    end
+
+    # Returns the object with HTTP headers associated with the response. All header names are lower-case.
+    def headers
+      raise NotImplementedError.new('headers is not implemented yet.')
+    end
+
+    # Returns the JSON representation of response body.
+    # This method will throw if the response body is not parsable via `JSON.parse`.
+    def json
+      raise NotImplementedError.new('json is not implemented yet.')
+    end
+
+    # Contains a boolean stating whether the response was successful (status in the range 200-299) or not.
+    def ok
+      raise NotImplementedError.new('ok is not implemented yet.')
+    end
+
+    # Returns the matching Request object.
+    def request
+      raise NotImplementedError.new('request is not implemented yet.')
+    end
+
+    # Contains the status code of the response (e.g., 200 for a success).
+    def status
+      raise NotImplementedError.new('status is not implemented yet.')
+    end
+
+    # Contains the status text of the response (e.g. usually an "OK" for a success).
+    def status_text
+      raise NotImplementedError.new('status_text is not implemented yet.')
+    end
+
+    # Returns the text representation of response body.
+    def text
+      raise NotImplementedError.new('text is not implemented yet.')
+    end
+
+    # Contains the URL of the response.
+    def url
+      raise NotImplementedError.new('url is not implemented yet.')
+    end
+  end
+end

data/lib/playwright_api/route.rb

@@ -0,0 +1,53 @@
+module Playwright
+  # Whenever a network route is set up with `page.route(url, handler)` or `browserContext.route(url, handler)`, the `Route` object allows to handle the route.
+  class Route < PlaywrightApi
+
+    # Aborts the route's request.
+    def abort(errorCode: nil)
+      raise NotImplementedError.new('abort is not implemented yet.')
+    end
+
+    # Continues route's request with optional overrides.
+    #
+    # ```js
+    # await page.route('**/*', (route, request) => {
+    #   // Override headers
+    #   const headers = {
+    #     ...request.headers(),
+    #     foo: 'bar', // set "foo" header
+    #     origin: undefined, // remove "origin" header
+    #   };
+    #   route.continue({headers});
+    # });
+    # ```
+    def continue(overrides: nil)
+      raise NotImplementedError.new('continue is not implemented yet.')
+    end
+
+    # Fulfills route's request with given response.
+    # An example of fulfilling all requests with 404 responses:
+    #
+    # ```js
+    # await page.route('**/*', route => {
+    #   route.fulfill({
+    #     status: 404,
+    #     contentType: 'text/plain',
+    #     body: 'Not Found!'
+    #   });
+    # });
+    # ```
+    # An example of serving static file:
+    #
+    # ```js
+    # await page.route('**/xhr_endpoint', route => route.fulfill({ path: 'mock_data.json' }));
+    # ```
+    def fulfill(response)
+      raise NotImplementedError.new('fulfill is not implemented yet.')
+    end
+
+    # A request to be routed.
+    def request
+      raise NotImplementedError.new('request is not implemented yet.')
+    end
+  end
+end

data/lib/playwright_api/selectors.rb

@@ -0,0 +1,51 @@
+module Playwright
+  # Selectors can be used to install custom selector engines. See Working with selectors for more information.
+  class Selectors < PlaywrightApi
+
+    # An example of registering selector engine that queries elements based on a tag name:
+    #
+    # ```js
+    # const { selectors, firefox } = require('playwright');  // Or 'chromium' or 'webkit'.
+    # 
+    # (async () => {
+    #   // Must be a function that evaluates to a selector engine instance.
+    #   const createTagNameEngine = () => ({
+    #     // Creates a selector that matches given target when queried at the root.
+    #     // Can return undefined if unable to create one.
+    #     create(root, target) {
+    #       return root.querySelector(target.tagName) === target ? target.tagName : undefined;
+    #     },
+    # 
+    #     // Returns the first element matching given selector in the root's subtree.
+    #     query(root, selector) {
+    #       return root.querySelector(selector);
+    #     },
+    # 
+    #     // Returns all elements matching given selector in the root's subtree.
+    #     queryAll(root, selector) {
+    #       return Array.from(root.querySelectorAll(selector));
+    #     }
+    #   });
+    # 
+    #   // Register the engine. Selectors will be prefixed with "tag=".
+    #   await selectors.register('tag', createTagNameEngine);
+    # 
+    #   const browser = await firefox.launch();
+    #   const page = await browser.newPage();
+    #   await page.setContent(`<div><button>Click me</button></div>`);
+    # 
+    #   // Use the selector prefixed with its name.
+    #   const button = await page.$('tag=button');
+    #   // Combine it with other selector engines.
+    #   await page.click('tag=div >> text="Click me"');
+    #   // Can use it in any methods supporting selectors.
+    #   const buttonCount = await page.$$eval('tag=button', buttons => buttons.length);
+    # 
+    #   await browser.close();
+    # })();
+    # ```
+    def register(name, script, contentScript: nil)
+      raise NotImplementedError.new('register is not implemented yet.')
+    end
+  end
+end

data/lib/playwright_api/touchscreen.rb

@@ -0,0 +1,10 @@
+module Playwright
+  # The Touchscreen class operates in main-frame CSS pixels relative to the top-left corner of the viewport. Methods on the touchscreen can only be used in browser contexts that have been intialized with `hasTouch` set to true.
+  class Touchscreen < PlaywrightApi
+
+    # Dispatches a `touchstart` and `touchend` event with a single touch at the position (`x`,`y`).
+    def tap_point(x, y)
+      raise NotImplementedError.new('tap_point is not implemented yet.')
+    end
+  end
+end

data/lib/playwright_api/video.rb

@@ -0,0 +1,14 @@
+module Playwright
+  # When browser context is created with the `videosPath` option, each page has a video object associated with it.
+  #
+  # ```js
+  # console.log(await page.video().path());
+  # ```
+  class Video < PlaywrightApi
+
+    # Returns the file system path this video will be recorded to. The video is guaranteed to be written to the filesystem upon closing the browser context.
+    def path
+      raise NotImplementedError.new('path is not implemented yet.')
+    end
+  end
+end

data/lib/playwright_api/web_socket.rb

@@ -0,0 +1,21 @@
+module Playwright
+  # The WebSocket class represents websocket connections in the page.
+  class WebSocket < PlaywrightApi
+
+    # Indicates that the web socket has been closed.
+    def closed?
+      raise NotImplementedError.new('closed? is not implemented yet.')
+    end
+
+    # Contains the URL of the WebSocket.
+    def url
+      raise NotImplementedError.new('url is not implemented yet.')
+    end
+
+    # Returns the event data value.
+    # 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.
+    def wait_for_event(event, optionsOrPredicate: nil)
+      raise NotImplementedError.new('wait_for_event is not implemented yet.')
+    end
+  end
+end

data/lib/playwright_api/worker.rb

@@ -0,0 +1,34 @@
+module Playwright
+  # The Worker class represents a WebWorker. `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());
+  # ```
+  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 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 the promise to resolve and return its value.
+    def evaluate_handle(pageFunction, arg: nil)
+      raise NotImplementedError.new('evaluate_handle is not implemented yet.')
+    end
+
+    def url
+      raise NotImplementedError.new('url is not implemented yet.')
+    end
+  end
+end

data/playwright.gemspec

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'playwright/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'playwright-ruby-client'
+  spec.version       = Playwright::VERSION
+
+  spec.authors       = ['YusukeIwaki']
+  spec.email         = ['q7w8e9w8q7w8e9@yahoo.co.jp']
+
+  spec.summary       = 'The Ruby binding of playwright driver'
+  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/")
+    end
+  end + `find lib/playwright_api -name *.rb -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.add_development_dependency 'bundler', '~> 2.2.3'
+  spec.add_development_dependency 'dry-inflector'
+  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 'rubocop-rspec'
+end

metadata

@@ -0,0 +1,216 @@
+--- !ruby/object:Gem::Specification
+name: playwright-ruby-client
+version: !ruby/object:Gem::Version
+  version: 0.0.3
+platform: ruby
+authors:
+- YusukeIwaki
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2021-01-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: concurrent-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.2.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.2.3
+- !ruby/object:Gem::Dependency
+  name: dry-inflector
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 13.0.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 13.0.3
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.10.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.10.0
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.7.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.7.0
+- !ruby/object:Gem::Dependency
+  name: rubocop-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email:
+- q7w8e9w8q7w8e9@yahoo.co.jp
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/playwright.rb
+- lib/playwright/channel.rb
+- lib/playwright/channel_owner.rb
+- lib/playwright/channel_owners/android.rb
+- lib/playwright/channel_owners/binding_call.rb
+- lib/playwright/channel_owners/browser.rb
+- lib/playwright/channel_owners/browser_context.rb
+- lib/playwright/channel_owners/browser_type.rb
+- lib/playwright/channel_owners/chromium_browser.rb
+- lib/playwright/channel_owners/chromium_browser_context.rb
+- lib/playwright/channel_owners/electron.rb
+- lib/playwright/channel_owners/firefox_browser.rb
+- lib/playwright/channel_owners/frame.rb
+- lib/playwright/channel_owners/page.rb
+- lib/playwright/channel_owners/playwright.rb
+- lib/playwright/channel_owners/request.rb
+- lib/playwright/channel_owners/response.rb
+- lib/playwright/channel_owners/selectors.rb
+- lib/playwright/channel_owners/webkit_browser.rb
+- lib/playwright/connection.rb
+- lib/playwright/errors.rb
+- lib/playwright/event_emitter.rb
+- lib/playwright/events.rb
+- lib/playwright/playwright_api.rb
+- lib/playwright/transport.rb
+- lib/playwright/version.rb
+- lib/playwright_api/accessibility.rb
+- lib/playwright_api/binding_call.rb
+- lib/playwright_api/browser.rb
+- lib/playwright_api/browser_context.rb
+- lib/playwright_api/browser_type.rb
+- lib/playwright_api/cdp_session.rb
+- lib/playwright_api/chromium_browser_context.rb
+- lib/playwright_api/console_message.rb
+- lib/playwright_api/dialog.rb
+- lib/playwright_api/download.rb
+- lib/playwright_api/element_handle.rb
+- lib/playwright_api/file_chooser.rb
+- lib/playwright_api/frame.rb
+- lib/playwright_api/js_handle.rb
+- lib/playwright_api/keyboard.rb
+- lib/playwright_api/mouse.rb
+- lib/playwright_api/page.rb
+- lib/playwright_api/playwright.rb
+- lib/playwright_api/request.rb
+- lib/playwright_api/response.rb
+- lib/playwright_api/route.rb
+- lib/playwright_api/selectors.rb
+- lib/playwright_api/touchscreen.rb
+- lib/playwright_api/video.rb
+- lib/playwright_api/web_socket.rb
+- lib/playwright_api/worker.rb
+- playwright.gemspec
+homepage: https://github.com/YusukeIwaki/playwright-ruby-client
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.3
+signing_key: 
+specification_version: 4
+summary: The Ruby binding of playwright driver
+test_files: []