puppeteer-ruby 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 4f42c72b65d27578da2dbdbbc4dac1544bb0a0038ba3c35ffd8f298dafc47f14
+  data.tar.gz: c1fe854ee2566bb9c8993e42cf71b881ff9c87a709150bb7cddd09a6d952901d
+SHA512:
+  metadata.gz: ef51d01afe77f2c1bf31ed70a7bfe3a629377b32b69ceb265413876802639ef5c44de08856b0bfaa69bbddf7bf41a6aaef01bd7e4a2c4a516ec21b645b7caede
+  data.tar.gz: 7a876a89710c9fd956377b01ce41d463a6fd547805991f8778bd89086182a4800459bb6cf5d6009ea8a363629993f4bdd333263475c1e24cfb3a99f9b886e53e

data/.gitignore

@@ -0,0 +1,19 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+/.vscode
+/Gemfile.lock
+/vendor/bundle
+
+# rspec failure tracking
+.rspec_status
+
+# RubyMine
+/.idea/
+/.rakeTasks

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,36 @@
+Layout/LineLength:
+  Max: 120
+
+Style/AccessModifierDeclarations:
+  EnforcedStyle: inline
+
+Style/ClassAndModuleChildren:
+  EnforcedStyle: compact
+
+Style/FrozenStringLiteralComment:
+  Enabled: false
+
+Style/HashEachMethods:
+  Enabled: true
+
+Style/HashTransformKeys:
+  Enabled: true
+
+Style/HashTransformValues:
+  Enabled: true
+
+Style/RaiseArgs:
+  Enabled: true
+  EnforcedStyle: compact
+
+Style/TrailingCommaInArguments:
+  Enabled: true
+  EnforcedStyleForMultiline: comma
+
+Style/TrailingCommaInArrayLiteral:
+  Enabled: true
+  EnforcedStyleForMultiline: comma
+
+Style/TrailingCommaInHashLiteral:
+  Enabled: true
+  EnforcedStyleForMultiline: comma

data/.travis.yml

@@ -0,0 +1,7 @@
+---
+sudo: false
+language: ruby
+cache: bundler
+rvm:
+  - 2.6.3
+before_install: gem install bundler -v 1.17.2

data/Dockerfile

@@ -0,0 +1,6 @@
+FROM ruby:2.6.5
+
+RUN wget -q -O - https://dl-ssl.google.com/linux/linux_signing_key.pub | apt-key add - \
+    && sh -c 'echo "deb [arch=amd64] http://dl.google.com/linux/chrome/deb/ stable main" >> /etc/apt/sources.list.d/google.list' \
+    && apt-get update && apt-get install -y google-chrome-stable --no-install-recommends \
+    && rm -rf /var/lib/apt/lists/*

data/Gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+git_source(:github) { |repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in puppeteer-ruby.gemspec
+gemspec

data/README.md

@@ -0,0 +1,41 @@
+# Puppeteer in Ruby [UNDER HEAVY DEVELOPMENT]
+
+A Ruby port of [puppeteer](https://pptr.dev/).
+
+REMARK: This Gem is NOT production-ready!!
+
+## Getting Started
+
+Simple usage:
+
+```ruby
+require 'puppeteer'
+
+Puppeteer.launch(headless: false, slow_mo: 50, args: ['--guest', '--window-size=1280,800']) do |browser|
+  page = browser.pages.first || browser.new_page
+  page.viewport = Puppeteer::Viewport.new(width: 1280, height: 800)
+  page.goto("https://github.com/", wait_until: 'domcontentloaded')
+
+  form = page.S("form.js-site-search-form")
+  searchInput = form.S("input.header-search-input")
+  searchInput.type_text("puppeteer")
+  await_all(
+    page.async_wait_for_navigation,
+    searchInput.async_press("Enter"),
+  )
+
+  list = page.S("ul.repo-list")
+  items = list.SS("div.f4")
+  items.each do |item|
+    title = item.Seval("a", "a => a.innerText")
+    puts("==> #{title}")
+  end
+end
+```
+
+![puppeteer-ruby](https://user-images.githubusercontent.com/11763113/78505735-6e7f3000-77b0-11ea-9c82-9016828dd2a9.gif)
+
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/YusukeIwaki/puppeteer-ruby.

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/console

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'puppeteer'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+require "pry"
+Pry.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/docker-compose.yml

@@ -0,0 +1,15 @@
+version: "3"
+services:
+  dev:
+    image: ruby-with-chrome:2.6
+    build:
+      context: .
+      dockerfile: Dockerfile
+    volumes:
+      - .:/usr/src/app
+      - bundler-cache:/usr/local/bundle
+    working_dir: /usr/src/app
+
+volumes:
+  bundler-cache:
+    driver: local

data/example.rb

@@ -0,0 +1,7 @@
+require 'puppeteer';
+
+Puppeteer.launch(headless: false) do |browser|
+  page = browser.pages.first || browser.new_page
+  page.goto("https://github.com/YusukeIwaki")
+  page.screenshot(path: "YusukeIwaki.png")
+end

data/lib/puppeteer.rb

@@ -0,0 +1,192 @@
+require 'concurrent'
+
+class Puppeteer ; end
+
+# Custom data types.
+require 'puppeteer/device'
+require 'puppeteer/errors'
+require 'puppeteer/viewport'
+
+# Modules
+require 'puppeteer/async_await_behavior'
+require 'puppeteer/concurrent_ruby_utils'
+require 'puppeteer/debug_print'
+require 'puppeteer/event_callbackable'
+require 'puppeteer/if_present'
+
+# Classes & values.
+require 'puppeteer/browser'
+require 'puppeteer/browser_context'
+require 'puppeteer/browser_runner'
+require 'puppeteer/cdp_session'
+require 'puppeteer/connection'
+require 'puppeteer/console_message'
+require 'puppeteer/devices'
+require 'puppeteer/dom_world'
+require 'puppeteer/emulation_manager'
+require 'puppeteer/execution_context'
+require 'puppeteer/frame'
+require 'puppeteer/frame_manager'
+require 'puppeteer/js_handle'
+require 'puppeteer/keyboard'
+require 'puppeteer/launcher'
+require 'puppeteer/lifecycle_watcher'
+require 'puppeteer/mouse'
+require 'puppeteer/network_manager'
+require 'puppeteer/page'
+require 'puppeteer/remote_object'
+require 'puppeteer/target'
+require 'puppeteer/timeout_settings'
+require 'puppeteer/touch_screen'
+require 'puppeteer/version'
+require 'puppeteer/wait_task'
+require 'puppeteer/web_socket'
+require 'puppeteer/web_socket_transport'
+
+# subclasses
+require 'puppeteer/element_handle'
+
+# ref: https://github.com/puppeteer/puppeteer/blob/master/lib/Puppeteer.js
+class Puppeteer
+  class << self
+    def method_missing(method, *args, **kwargs, &block)
+      instance.send(method, *args, **kwargs, &block)
+    end
+
+    def instance
+      @instance ||= Puppeteer.new(
+                      project_root: __dir__,
+                      preferred_revision: "706915",
+                      is_puppeteer_core: true)
+    end
+  end
+
+  # @param {string} projectRoot
+  # @param {string} preferredRevision
+  # @param {boolean} isPuppeteerCore
+  def initialize(project_root:, preferred_revision:, is_puppeteer_core:)
+    @project_root = project_root
+    @preferred_revision = preferred_revision
+    @is_puppeteer_core = is_puppeteer_core
+  end
+
+  # @param {!(Launcher.LaunchOptions & Launcher.ChromeArgOptions & Launcher.BrowserOptions & {product?: string, extraPrefsFirefox?: !object})=} options
+  # @return {!Promise<!Puppeteer.Browser>}
+  def launch(
+    product: nil,
+    executable_path: nil,
+    ignore_default_args: nil,
+    handle_SIGINT: nil,
+    handle_SIGTERM: nil,
+    handle_SIGHUP: nil,
+    timeout: nil,
+    dumpio: nil,
+    env: nil,
+    pipe: nil,
+    args: nil,
+    user_data_dir: nil,
+    devtools: nil,
+    headless: nil,
+    ignore_https_errors: nil,
+    default_viewport: nil,
+    slow_mo: nil
+  )
+    options = {
+      executable_path: executable_path,
+      ignore_default_args: ignore_default_args,
+      handle_SIGINT: handle_SIGINT,
+      handle_SIGTERM: handle_SIGTERM,
+      handle_SIGHUP: handle_SIGHUP,
+      timeout: timeout,
+      dumpio: dumpio,
+      env: env,
+      pipe: pipe,
+      args: args,
+      user_data_dir: user_data_dir,
+      devtools: devtools,
+      headless: headless,
+      ignore_https_errors: ignore_https_errors,
+      default_viewport: default_viewport,
+      slow_mo: slow_mo,
+    }.compact
+
+    @product_name ||= product
+    browser = launcher.launch(options)
+    if block_given?
+      begin
+        yield(browser)
+      ensure
+        browser.close
+      end
+    else
+      browser
+    end
+  end
+
+  # @param {!(Launcher.BrowserOptions & {browserWSEndpoint?: string, browserURL?: string, transport?: !Puppeteer.ConnectionTransport})} options
+  # @return {!Promise<!Puppeteer.Browser>}
+  def connect(
+    browser_ws_endpoint: nil,
+    browser_url: nil,
+    transport: nil,
+    ignore_https_errors: nil,
+    default_viewport: nil,
+    slow_mo: nil
+  )
+    options = {
+      browser_ws_endpoint: browser_ws_endpoint,
+      browser_url: browser_url,
+      transport: transport,
+      ignore_https_errors: ignore_https_errors,
+      default_viewport: default_viewport,
+      slow_mo: slow_mo,
+    }.compact
+    launcher.connect(options)
+  end
+
+  # @return {string}
+  def executable_path
+    launcher.executable_path
+  end
+
+  private def launcher
+    @launcher ||= Puppeteer::Launcher.new(
+                    project_root: @project_root,
+                    preferred_revision: @preferred_revision,
+                    is_puppeteer_core: @is_puppeteer_core,
+                    product: @product_name)
+  end
+
+  # @return {string}
+  def product
+    launcher.product
+  end
+
+  # @return {Puppeteer::Devices}
+  def devices
+    Puppeteer::Devices
+  end
+
+  # # @return {Object}
+  # def errors
+  #   # ???
+  # end
+
+  # @param {!Launcher.ChromeArgOptions=} options
+  # @return {!Array<string>}
+  def default_args(args: nil, user_data_dir: nil, devtools: nil, headless: nil)
+    options = {
+      args: args,
+      user_data_dir: user_data_dir,
+      devtools: devtools,
+      headless: headless,
+    }.compact
+    launcher.default_args(options)
+  end
+
+  # @param {!BrowserFetcher.Options=} options
+  # @return {!BrowserFetcher}
+  def createBrowserFetcher(options = {})
+    BrowserFetcher.new(@project_root, options)
+  end
+end

data/lib/puppeteer/async_await_behavior.rb

@@ -0,0 +1,34 @@
+module Puppeteer::AsyncAwaitBehavior
+  refine Class do
+    # wrap with Concurrent::Promises.future
+    def async(method_name)
+      begin
+        original_method = instance_method(method_name)
+
+        unless method_name.to_s.start_with?("async_")
+          puts "async method should start with 'async_': #{self.name}##{method_name}"
+        end
+
+        define_method(method_name) do |*args|
+          Concurrent::Promises.future {
+            original_method.bind(self).call(*args)
+          }
+        end
+      rescue NameError
+        if respond_to?(method_name)
+          original_method = singleton_method(method_name)
+
+          unless method_name.to_s.start_with?("async_")
+            puts "async method should start with 'async_': #{method_name}"
+          end
+
+          define_singleton_method(method_name) do |*args|
+            Concurrent::Promises.future {
+              original_method.call(*args)
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/puppeteer/browser.rb

@@ -0,0 +1,240 @@
+require 'thread'
+require 'timeout'
+
+class Puppeteer::Browser
+  include Puppeteer::DebugPrint
+  include Puppeteer::EventCallbackable
+  using Puppeteer::AsyncAwaitBehavior
+
+  # @param {!Puppeteer.Connection} connection
+  # @param {!Array<string>} contextIds
+  # @param {boolean} ignoreHTTPSErrors
+  # @param {?Puppeteer.Viewport} defaultViewport
+  # @param process [Puppeteer::BrowserRunner::BrowserProcess|NilClass]
+  # @param {function()=} closeCallback
+  def self.create(connection:, context_ids:, ignore_https_errors:, default_viewport:, process:, close_callback:)
+    browser = Puppeteer::Browser.new(
+      connection: connection,
+      context_ids: context_ids,
+      ignore_https_errors: ignore_https_errors,
+      default_viewport: default_viewport,
+      process: process,
+      close_callback: close_callback,
+    )
+    connection.send_message('Target.setDiscoverTargets', discover: true)
+    browser
+  end
+
+  # @param {!Puppeteer.Connection} connection
+  # @param {!Array<string>} contextIds
+  # @param {boolean} ignoreHTTPSErrors
+  # @param {?Puppeteer.Viewport} defaultViewport
+  # @param {?Puppeteer.ChildProcess} process
+  # @param {(function():Promise)=} closeCallback
+  def initialize(connection:, context_ids:, ignore_https_errors:, default_viewport:, process:, close_callback:)
+    @ignore_https_errors = ignore_https_errors
+    @default_viewport = default_viewport
+    @process = process
+    # @screenshot_task_queue = TaskQueue.new
+    @connection = connection
+    @close_callback = close_callback
+
+    @default_context = Puppeteer::BrowserContext.new(@connection, self, nil)
+    @contexts = {}
+    context_ids.each do |context_id|
+      @contexts[context_id] = Puppeteer::BrowserContext.new(@connection, self. context_id)
+    end
+    @targets = {}
+    @connection.on_event 'Events.CDPSession.Disconnected' do
+      emit_event 'Events.Browser.Disconnected'
+    end
+    @connection.on_event 'Target.targetCreated', &method(:handle_target_created)
+    @connection.on_event 'Target.targetDestroyed', &method(:handle_target_destroyed)
+    @connection.on_event 'Target.targetInfoChanged', &method(:handle_target_info_changed)
+  end
+
+  # @return [Puppeteer::BrowserRunner::BrowserProcess]
+  def process
+    @process
+  end
+
+  # @return [Puppeteer::BrowserContext]
+  def create_incognito_browser_context
+    result = @connection.send_message('Target.createBrowserContext')
+    browser_context_id = result['browserContextId']
+    @contexts[browser_context_id] = Puppeteer::BrowserContext.new(@connection, self, browser_context_id)
+  end
+
+  def browser_contexts
+    [@default_context].concat(@contexts.values)
+  end
+
+  # @return [Puppeteer::BrowserContext]
+  def default_browser_context
+    @default_context
+  end
+
+  # @param context_id [String]
+  def dispose_context(context_id)
+    @connection.send_message('Target.disposeBrowserContext', browserContextId: context_id)
+    @contexts.remove(context_id)
+  end
+
+  # @param {!Protocol.Target.targetCreatedPayload} event
+  def handle_target_created(event)
+    target_info = Puppeteer::Target::TargetInfo.new(event['targetInfo'])
+    browser_context_id = target_info.browser_context_id
+    context =
+      if browser_context_id && @contexts.has_key?(browser_context_id)
+        @contexts[browser_context_id]
+      else
+        @default_context
+      end
+
+    target = Puppeteer::Target.new(
+      target_info: target_info,
+      browser_context: context,
+      session_factory: ->{ @connection.create_session(target_info) },
+      ignore_https_errors: @ignore_https_errors,
+      default_viewport: @default_viewport,
+      screenshot_task_queue: @screenshot_task_queue,
+    )
+    #   assert(!this._targets.has(event.targetInfo.targetId), 'Target should not exist before targetCreated');
+    @targets[target_info.target_id] = target
+
+    target.on_initialize_succeeded do
+      emit_event 'Events.Browser.TargetCreated', target
+      context.emit_event 'Events.BrowserContext.TargetCreated', target
+    end
+  end
+
+
+  # @param {{targetId: string}} event
+  def handle_target_destroyed(event)
+    target_id = event['targetId']
+    target = @targets[target_id]
+    target.handle_initialized(false)
+    @targets.delete(target_id)
+    target.handle_closed
+    target.on_initialize_succeeded do
+      emit_event 'Events.Browser.TargetDestroyed', target
+      target.browser_context.emit_event 'Events.BrowserContext.TargetDestroyed', target
+    end
+  end
+
+  # @param {!Protocol.Target.targetInfoChangedPayload} event
+  def handle_target_info_changed(event)
+    target_info = Puppeteer::Target::TargetInfo.new(event['targetInfo'])
+    target = @targets[target_info.target_id]
+    if !target
+      throw StandardError.new('target should exist before targetInfoChanged')
+    end
+    previous_url = target.url
+    was_initialized = target.initialized?
+    target.handle_target_info_changed(target_info)
+    if was_initialized && previous_url != target.url
+      emit_event 'Events.Browser.TargetChanged', target
+      target.browser_context.emit_event 'Events.BrowserContext.TargetChanged', target
+    end
+  end
+
+  # @return [String]
+  def websocket_endpoint
+    @connection.url
+  end
+
+  def new_page
+    @default_context.new_page
+  end
+
+  # @param {?string} contextId
+  # @return {!Promise<!Puppeteer.Page>}
+  def create_page_in_context(context_id)
+    create_target_params = { url: 'about:blank' }
+    if context_id
+      create_target_params[:browserContextId] = context_id
+    end
+    result = @connection.send_message('Target.createTarget', **create_target_params)
+    target_id = result['targetId']
+    target = @targets[target_id]
+    await target.initialized_promise
+    await target.page;
+  end
+
+  # @return {!Array<!Target>}
+  def targets
+    @targets.values.select{ |target| target.initialized? }
+  end
+
+
+  # @return {!Target}
+  def target
+    targets.first{ |target| target.type == 'browser' }
+  end
+
+  # @param {function(!Target):boolean} predicate
+  # @param {{timeout?: number}=} options
+  # @return {!Promise<!Target>}
+  def wait_for_target(predicate:, timeout: nil)
+    timeout_in_sec = (timeout || 30000).to_i / 1000.0
+    existing_target = targets.first{ |target| predicate.call(target) }
+    return existing_target if existing_target
+
+    event_listening_ids = []
+    target_promise = resolvable_future
+    event_listening_ids << add_event_listener('Events.Browser.TargetCreated') do |target|
+      if predicate.call(target)
+        target_promise.fulfill(target)
+      end
+    end
+    event_listening_ids << add_event_listener('Events.Browser.TargetChanged') do |target|
+      if predicate.call(target)
+        target_promise.fulfill(target)
+      end
+    end
+
+    begin
+      if timeout_in_sec > 0
+        Timeout.timeout(timeout_in_sec) do
+          target_promise.value!
+        end
+      else
+        target_promise.value!
+      end
+    ensure
+      remove_event_listener(*event_listening_ids)
+    end
+  end
+
+  # @return {!Promise<!Array<!Puppeteer.Page>>}
+  def pages
+    browser_contexts.flat_map(&:pages)
+  end
+
+  # @return [String]
+  def version
+    get_version.product
+  end
+
+  # @return [String]
+  def user_agent
+    get_version.user_agent
+  end
+
+  def close
+    @close_callback.call
+    disconnect
+  end
+
+  def disconnect
+    @connection.dispose
+  end
+
+  def connected?
+    !@connection.closed?
+  end
+
+  private def get_version
+    @connection.send_message('Browser.getVersion')
+  end
+end