puppeteer-ruby 0.0.10

data/lib/puppeteer/element_handle/point.rb

@@ -0,0 +1,26 @@
+class Puppeteer::ElementHandle < Puppeteer::JSHandle
+  # A class to represent (x, y)-coordinates
+  # supporting + and / operators.
+  class Point
+    def initialize(x:, y:)
+      @x = x
+      @y = y
+    end
+
+    def +(other)
+      Point.new(
+        x: @x + other.x,
+        y: @y + other.y,
+      )
+    end
+
+    def /(num)
+      Point.new(
+        x: @x / num,
+        y: @y / num,
+      )
+    end
+
+    attr_reader :x, :y
+  end
+end

data/lib/puppeteer/emulation_manager.rb

@@ -0,0 +1,46 @@
+class Puppeteer::EmulationManager
+  using Puppeteer::AsyncAwaitBehavior
+
+  # @param {!Puppeteer.CDPSession} client
+  def initialize(client)
+    @client = client
+    @emulating_mobile = false
+    @has_touch = false
+  end
+
+  # @param viewport [Puppeteer::Viewport]
+  # @return [true|false]
+  def emulate_viewport(viewport)
+    mobile = viewport.mobile?
+    width = viewport.width
+    height = viewport.height
+    device_scale_factor = viewport.device_scale_factor
+    # /** @type {Protocol.Emulation.ScreenOrientation} */
+    # const screenOrientation = viewport.isLandscape ? { angle: 90, type: 'landscapePrimary' } : { angle: 0, type: 'portraitPrimary' };
+    has_touch = viewport.has_touch?
+
+    await_all(
+      @client.async_send_message('Emulation.setDeviceMetricsOverride',
+        mobile: mobile,
+        width: width,
+        height: height,
+        deviceScaleFactor: device_scale_factor,
+        # screenOrientation: screen_orientation,
+      ),
+      @client.async_send_message('Emulation.setTouchEmulationEnabled',
+        enabled: has_touch,
+      ),
+    )
+
+    reload_needed = @emulating_mobile != mobile || @hasTouch != has_touch
+    @emulating_mobile = mobile
+    @has_touch = has_touch
+    reload_needed
+  end
+
+  # @param viewport [Puppeteer::Viewport]
+  # @return [Future<true|false>]
+  async def async_emulate_viewport(viewport)
+    emulate_viewport(viewport)
+  end
+end

data/lib/puppeteer/errors.rb

@@ -0,0 +1,2 @@
+# ref: https://github.com/puppeteer/puppeteer/blob/master/src/Errors.ts
+class Puppeteer::TimeoutError < StandardError; end

data/lib/puppeteer/event_callbackable.rb

@@ -0,0 +1,88 @@
+require 'securerandom'
+
+module Puppeteer::EventCallbackable
+  class EventListeners
+    include Enumerable
+
+    def initialize
+      @listeners = {}
+    end
+
+    # @return [String] Listener ID
+    def add(&block)
+      id = SecureRandom.hex(8)
+      @listeners[id] = block
+      id
+    end
+
+    # @param id [String] Listener ID returned on #add
+    def delete(id)
+      @listeners.delete(id)
+    end
+
+    # @implement Enumerable#each
+    def each(&block)
+      @listeners.values.each(&block)
+    end
+  end
+
+  def add_event_listener(event_name, &block)
+    @event_listeners ||= {}
+    (@event_listeners[event_name] ||= EventListeners.new).add(&block)
+  end
+
+  def remove_event_listener(*id_args)
+    (@event_listeners ||= {}).each do |event_name, listeners|
+      id_args.each do |id|
+        listeners.delete(id)
+      end
+    end
+  end
+
+  def on_event(event_name, &block)
+    @event_callbackable_handlers ||= {}
+    @event_callbackable_handlers[event_name] = block
+  end
+
+  def emit_event(event_name, *args, **kwargs)
+    @event_callbackable_handlers ||= {}
+    @event_listeners ||= {}
+
+    if kwargs.empty?
+      # In Ruby's specification (version < 2.7),
+      # `method(:x).call(*args, **kwargs)` is equivalent to `x(*args, {})`
+      # It often causes unexpected ArgumentError.
+      #
+      # ----------------
+      # def greet
+      #   puts 'Hello!'
+      # end
+      #
+      # def call_me(*args, **kwargs)
+      #   greet(*args, **kwargs) # => 'Hello!'
+      #
+      #   method(:greet).call(*args, **kwargs) # => `greet': wrong number of arguments (given 1, expected 0) (ArgumentError)
+      # end
+      #
+      # call_me
+      # ----------------
+      #
+      # This behavior is really annoying, and should be avoided, because we often want to set event handler as below:
+      #
+      # `on_event 'Some.Event.awesome', &method(:handle_awesome_event)`
+      #
+      # So Let's avoid it by checking kwargs.
+      @event_callbackable_handlers[event_name]&.call(*args)
+      @event_listeners[event_name]&.each do |proc|
+        proc.call(*args)
+      end
+    else
+      @event_callbackable_handlers[event_name]&.call(*args, **kwargs)
+      @event_listeners[event_name]&.each do |proc|
+        proc.call(*args, **kwargs)
+      end
+    end
+
+    event_name
+  end
+end

data/lib/puppeteer/execution_context.rb

@@ -0,0 +1,254 @@
+class Puppeteer::ExecutionContext
+  include Puppeteer::IfPresent
+  using Puppeteer::AsyncAwaitBehavior
+
+  EVALUATION_SCRIPT_URL = '__puppeteer_evaluation_script__'
+  SOURCE_URL_REGEX = /^[\040\t]*\/\/[@#] sourceURL=\s*(\S*?)\s*$/m
+
+  # @param client [Puppeteer::CDPSession]
+  # @param context_payload [Hash]
+  # @param world [Puppeteer::DOMWorld?]
+  def initialize(client, context_payload, world)
+    @client = client
+    @world = world
+    @context_id = context_payload['id']
+  end
+
+  attr_reader :client, :world
+
+  # only used in DomWorld#delete_context
+  def _context_id
+    @context_id
+  end
+
+  # @return [Puppeteer::Frame]
+  def frame
+    if_present(@world) do |world|
+      world.frame
+    end
+  end
+
+  # @param page_function [String]
+  # @return [Object]
+  def evaluate(page_function, *args)
+    evaluate_internal(true, page_function, *args)
+  end
+
+  # @param page_function [String]
+  # @return [Puppeteer::JSHandle]
+  def evaluate_handle(page_function, *args)
+    evaluate_internal(false, page_function, *args)
+  end
+
+  class JavaScriptExpression
+    def initialize(execution_context, expression, return_by_value)
+      @execution_context = execution_context
+      @expression = expression
+      @return_by_value = return_by_value
+    end
+
+    # @param client [Puppeteer::CDPSession]
+    # @param context_id [String]
+    # @return [Object|JSHandle]
+    def evaluate_with(client:, context_id:)
+      result = client.send_message('Runtime.evaluate',
+        expression: expression_with_source_url,
+        contextId: context_id,
+        returnByValue: @return_by_value,
+        awaitPromise: true,
+        userGesture: true,
+      )
+      # }).catch(rewriteError);
+
+      exception_details = result['exceptionDetails']
+      if exception_details
+        raise EvaluationError.new("Evaluation failed: #{exception_details}")
+      end
+
+      remote_object = Puppeteer::RemoteObject.new(result['result'])
+      if @return_by_value
+        remote_object.value
+      else
+        Puppeteer::JSHandle.create(
+          context: @execution_context,
+          remote_object: remote_object,
+        )
+      end
+    end
+
+    private def suffix
+      "//# sourceURL=#{EVALUATION_SCRIPT_URL}"
+    end
+
+    private def expression_with_source_url
+      if SOURCE_URL_REGEX.match?(@expression)
+        @expression
+      else
+        "#{@expression}\n#{suffix}"
+      end
+    end
+  end
+
+  class JavaScriptFunction
+    include Puppeteer::IfPresent
+
+    def initialize(execution_context, expression, args, return_by_value)
+      @execution_context = execution_context
+      @expression = expression
+      @return_by_value = return_by_value
+      @args = args
+    end
+
+    # @param client [Puppeteer::CDPSession]
+    # @param context_id [String]
+    # @return [Object|JSHandle]
+    def evaluate_with(client:, context_id:)
+      # `function` can be omitted in JS after ES2015.
+      # https://developer.mozilla.org/ja/docs/Web/JavaScript/Reference/Operators/Object_initializer
+      #
+      # Original puppeteer implementation take it into consideration.
+      # But we don't support the syntax here.
+
+      result = client.send_message('Runtime.callFunctionOn',
+        functionDeclaration: "#{@expression}\n#{suffix}\n",
+        executionContextId: context_id,
+        arguments: converted_args,
+        returnByValue: @return_by_value,
+        awaitPromise: true,
+        userGesture: true,
+      ) # .catch(rewriteError);
+
+      exception_details = result['exceptionDetails']
+      remote_object = Puppeteer::RemoteObject.new(result['result'])
+
+      if exception_details
+        raise EvaluationError.new("Evaluation failed: #{exception_details}")
+      end
+
+      if @return_by_value
+        remote_object.value
+      else
+        Puppeteer::JSHandle.create(
+          context: @execution_context,
+          remote_object: remote_object,
+        )
+      end
+    end
+
+    private def converted_args
+      #     if (typeof arg === 'bigint') // eslint-disable-line valid-typeof
+      #       return { unserializableValue: `${arg.toString()}n` };
+      #     if (Object.is(arg, -0))
+      #       return { unserializableValue: '-0' };
+      #     if (Object.is(arg, Infinity))
+      #       return { unserializableValue: 'Infinity' };
+      #     if (Object.is(arg, -Infinity))
+      #       return { unserializableValue: '-Infinity' };
+      #     if (Object.is(arg, NaN))
+      #       return { unserializableValue: 'NaN' };
+      @args.map do |arg|
+        if arg && arg.is_a?(Puppeteer::JSHandle)
+          if arg.context != @execution_context
+            raise EvaluationError.new('JSHandles can be evaluated only in the context they were created!')
+          elsif arg.disposed?
+            raise EvaluationError.new('JSHandles is disposed!')
+          end
+
+          arg.remote_object.converted_arg
+        else
+          { value: arg }
+        end
+      end
+    end
+
+    #   /**
+    #    * @param {!Error} error
+    #    * @return {!Protocol.Runtime.evaluateReturnValue}
+    #    */
+    #   function rewriteError(error) {
+    #     if (error.message.includes('Object reference chain is too long'))
+    #       return {result: {type: 'undefined'}};
+    #     if (error.message.includes('Object couldn\'t be returned by value'))
+    #       return {result: {type: 'undefined'}};
+
+    #     if (error.message.endsWith('Cannot find context with specified id') || error.message.endsWith('Inspected target navigated or closed'))
+    #       throw new Error('Execution context was destroyed, most likely because of a navigation.');
+    #     throw error;
+    #   }
+
+    private def suffix
+      "//# sourceURL=#{EVALUATION_SCRIPT_URL}"
+    end
+  end
+
+  class EvaluationError < StandardError; end
+
+  # @param return_by_value [Boolean]
+  # @param page_function [String]
+  # @return [Object|Puppeteer::JSHandle]
+  private def evaluate_internal(return_by_value, page_function, *args)
+    # `function` can be omitted in JS after ES2015.
+    # https://developer.mozilla.org/ja/docs/Web/JavaScript/Reference/Operators/Object_initializer
+    # But we don't support the syntax here.
+    js_object =
+      if ['=>', 'async', 'function'].any? { |keyword| page_function.include?(keyword) }
+        JavaScriptFunction.new(self, page_function, args, return_by_value)
+      else
+        JavaScriptExpression.new(self, page_function, return_by_value)
+      end
+
+    js_object.evaluate_with(
+      client: @client,
+      context_id: @context_id,
+    )
+  end
+
+  # /**
+  #  * @param {!JSHandle} prototypeHandle
+  #  * @return {!Promise<!JSHandle>}
+  #  */
+  # async queryObjects(prototypeHandle) {
+  #   assert(!prototypeHandle._disposed, 'Prototype JSHandle is disposed!');
+  #   assert(prototypeHandle._remoteObject.objectId, 'Prototype JSHandle must not be referencing primitive value');
+  #   const response = await this._client.send('Runtime.queryObjects', {
+  #     prototypeObjectId: prototypeHandle._remoteObject.objectId
+  #   });
+  #   return createJSHandle(this, response.objects);
+  # }
+
+  # @param backend_node_id [Integer]
+  # @return [Puppeteer::ElementHandle]
+  def adopt_backend_node_id(backend_node_id)
+    response = @client.send_message('DOM.resolveNode',
+      backendNodeId: backend_node_id,
+      executionContextId: @context_id,
+    )
+    Puppeteer::JSHandle.create(
+      context: self,
+      remote_object: Puppeteer::RemoteObject.new(response["object"]),
+    )
+  end
+
+  # @param element_handle [Puppeteer::ElementHandle]
+  # @return [Puppeteer::ElementHandle]
+  def adopt_element_handle(element_handle)
+    if element_handle.execution_context == self
+      raise ArgumentError.new('Cannot adopt handle that already belongs to this execution context')
+    end
+
+    unless @world
+      raise 'Cannot adopt handle without DOMWorld'
+    end
+
+    node_info = element_handle.remote_object.node_info(@client)
+    response = @client.send_message('DOM.resolveNode',
+      backendNodeId: node_info["node"]["backendNodeId"],
+      executionContextId: @context_id,
+    )
+
+    Puppeteer::JSHandle.create(
+      context: self,
+      remote_object: Puppeteer::RemoteObject.new(response["object"]),
+    )
+  end
+end

data/lib/puppeteer/file_chooser.rb

@@ -0,0 +1,29 @@
+class Puppeteer::FileChooser
+  # @param element [Puppeteer::ElementHandle]
+  # @param event [Hash]
+  def initialize(element, event)
+    @element = element
+    @multiple = event['mode'] != 'selectSingle'
+    @handled = false
+  end
+
+  def multiple?
+    @multiple
+  end
+
+  # @param file_paths [Array<String>]
+  def accept(file_paths)
+    if @handled
+      raise 'Cannot accept FileChooser which is already handled!'
+    end
+    @handled = true
+    @element.upload_file(*file_paths)
+  end
+
+  def cancel
+    if @handled
+      raise 'Cannot cancel FileChooser which is already handled!'
+    end
+    @handled = true
+  end
+end