puppeteer-ruby 0.35.1 → 0.37.2

data/lib/puppeteer/js_coverage.rb

@@ -12,6 +12,14 @@ class Puppeteer::JSCoverage
     attr_reader :url, :ranges, :text
   end
 
+  class ItemWithRawScriptCoverage < Item
+    def initialize(url:, ranges:, text:, raw_script_coverage:)
+      super(url: url, ranges: ranges, text: text)
+      @raw_script_coverage = raw_script_coverage
+    end
+    attr_reader :raw_script_coverage
+  end
+
   # @param client [Puppeteer::CDPSession]
   def initialize(client)
     @client = client
@@ -20,7 +28,10 @@ class Puppeteer::JSCoverage
     @script_sources = {}
   end
 
-  def start(reset_on_navigation: nil, report_anonymous_scripts: nil)
+  def start(
+        reset_on_navigation: nil,
+        report_anonymous_scripts: nil,
+        include_raw_script_coverage: nil)
     raise 'JSCoverage is already enabled' if @enabled
 
     @reset_on_navigation =
@@ -30,6 +41,7 @@ class Puppeteer::JSCoverage
         true
       end
     @report_anonymous_scripts = report_anonymous_scripts || false
+    @include_raw_script_coverage = include_raw_script_coverage || false
     @enabled = true
     @script_urls.clear
     @script_sources.clear
@@ -43,7 +55,7 @@ class Puppeteer::JSCoverage
     await_all(
       @client.async_send_message('Profiler.enable'),
       @client.async_send_message('Profiler.startPreciseCoverage',
-        callCount: false,
+        callCount: @include_raw_script_coverage,
         detailed: true,
       ),
       @client.async_send_message('Debugger.enable'),
@@ -107,11 +119,20 @@ class Puppeteer::JSCoverage
         end
       end
 
-      coverage << Item.new(
-        url: url,
-        ranges: convert_to_disjoint_ranges(flatten_ranges),
-        text: text,
-      )
+      if @include_raw_script_coverage
+        coverage << ItemWithRawScriptCoverage.new(
+          url: url,
+          ranges: convert_to_disjoint_ranges(flatten_ranges),
+          text: text,
+          raw_script_coverage: entry,
+        )
+      else
+        coverage << Item.new(
+          url: url,
+          ranges: convert_to_disjoint_ranges(flatten_ranges),
+          text: text,
+        )
+      end
     end
 
     coverage

data/lib/puppeteer/launcher/launch_options.rb

@@ -35,9 +35,9 @@ module Puppeteer::Launcher
       @channel = options[:channel]
       @executable_path = options[:executable_path]
       @ignore_default_args = options[:ignore_default_args] || false
-      @handle_SIGINT = options[:handle_SIGINT] || true
-      @handle_SIGTERM = options[:handle_SIGTERM] || true
-      @handle_SIGHUP = options[:handle_SIGHUP] || true
+      @handle_SIGINT = options.fetch(:handle_SIGINT, true)
+      @handle_SIGTERM = options.fetch(:handle_SIGTERM, true)
+      @handle_SIGHUP = options.fetch(:handle_SIGHUP, true)
       @timeout = options[:timeout] || 30000
       @dumpio = options[:dumpio] || false
       @env = options[:env] || ENV

data/lib/puppeteer/lifecycle_watcher.rb

@@ -88,7 +88,7 @@ class Puppeteer::LifecycleWatcher
     check_lifecycle_complete
   end
 
-  # @param [Puppeteer::Request] request
+  # @param [Puppeteer::HTTPRequest] request
   def handle_request(request)
     return if request.frame != @frame || !request.navigation_request?
     @navigation_request = request
@@ -103,7 +103,7 @@ class Puppeteer::LifecycleWatcher
     check_lifecycle_complete
   end
 
-  # @return [Puppeteer::Response]
+  # @return [Puppeteer::HTTPResponse]
   def navigation_response
     if_present(@navigation_request) do |request|
       request.response

data/lib/puppeteer/mouse.rb

@@ -94,6 +94,8 @@ class Puppeteer::Mouse
     )
   end
 
+  define_async_method :async_up
+
   # Dispatches a `mousewheel` event.
   #
   # @param delta_x [Integer]
@@ -110,5 +112,56 @@ class Puppeteer::Mouse
     )
   end
 
-  define_async_method :async_up
+  def drag(start, target)
+    promise = resolvable_future do |f|
+      @client.once('Input.dragIntercepted') do |event|
+        f.fulfill(event['data'])
+      end
+    end
+    move(start.x, start.y)
+    down
+    move(target.x, target.y)
+    promise.value!
+  end
+
+  def drag_enter(target, data)
+    @client.send_message('Input.dispatchDragEvent',
+      type: 'dragEnter',
+      x: target.x,
+      y: target.y,
+      modifiers: @keyboard.modifiers,
+      data: data,
+    )
+  end
+
+  def drag_over(target, data)
+    @client.send_message('Input.dispatchDragEvent',
+      type: 'dragOver',
+      x: target.x,
+      y: target.y,
+      modifiers: @keyboard.modifiers,
+      data: data,
+    )
+  end
+
+  def drop(target, data)
+    @client.send_message('Input.dispatchDragEvent',
+      type: 'drop',
+      x: target.x,
+      y: target.y,
+      modifiers: @keyboard.modifiers,
+      data: data,
+    )
+  end
+
+  def drag_and_drop(start, target, delay: nil)
+    data = drag(start, target)
+    drag_enter(target, data)
+    drag_over(target, data)
+    if delay
+      sleep(delay / 1000.0)
+    end
+    drop(target, data)
+    up
+  end
 end

data/lib/puppeteer/network_condition.rb

@@ -0,0 +1,12 @@
+class Puppeteer::NetworkCondition
+  # @param download [Number] Download speed (bytes/s)
+  # @param upload [Number] Upload speed (bytes/s)
+  # @param latency [Number] Latency (ms)
+  def initialize(download:, upload:, latency:)
+    @download = download
+    @upload = upload
+    @latency = latency
+  end
+
+  attr_reader :download, :upload, :latency
+end

data/lib/puppeteer/network_conditions.rb

@@ -0,0 +1,24 @@
+require_relative './network_condition'
+
+Puppeteer::NETWORK_CONDITIONS = {
+  'Slow 3G' => Puppeteer::NetworkCondition.new(
+    download: ((500 * 1000) / 8) * 0.8,
+    upload: ((500 * 1000) / 8) * 0.8,
+    latency: 400 * 5,
+  ),
+  'Fast 3G' => Puppeteer::NetworkCondition.new(
+    download: ((1.6 * 1000 * 1000) / 8) * 0.9,
+    upload: ((750 * 1000) / 8) * 0.9,
+    latency: 150 * 3.75,
+  ),
+}
+
+module Puppeteer::NetworkConditions
+  module_function def slow_3g
+    Puppeteer::NETWORK_CONDITIONS['Slow 3G']
+  end
+
+  module_function def fast_3g
+    Puppeteer::NETWORK_CONDITIONS['Fast 3G']
+  end
+end

data/lib/puppeteer/network_manager.rb

@@ -13,6 +13,46 @@ class Puppeteer::NetworkManager
     attr_reader :username, :password
   end
 
+  class InternalNetworkCondition
+    attr_writer :offline, :upload, :download, :latency
+
+    def initialize(client)
+      @client = client
+      @offline = false
+      @upload = -1
+      @download = -1
+      @latency = 0
+    end
+
+    def offline_mode=(value)
+      return if @offline == value
+      @offline = value
+      update_network_conditions
+    end
+
+    def network_condition=(network_condition)
+      if network_condition
+        @upload = network_condition.upload
+        @download = network_condition.download
+        @latency = network_condition.latency
+      else
+        @upload = -1
+        @download = -1
+        @latency = 0
+      end
+      update_network_conditions
+    end
+
+    private def update_network_conditions
+      @client.send_message('Network.emulateNetworkConditions',
+        offline: @offline,
+        latency: @latency,
+        downloadThroughput: @download,
+        uploadThroughput: @upload,
+      )
+    end
+  end
+
   # @param {!Puppeteer.CDPSession} client
   # @param {boolean} ignoreHTTPSErrors
   # @param {!Puppeteer.FrameManager} frameManager
@@ -29,13 +69,12 @@ class Puppeteer::NetworkManager
 
     @extra_http_headers = {}
 
-    @offline = false
-
     @attempted_authentications = Set.new
     @user_request_interception_enabled = false
     @protocol_request_interception_enabled = false
     @user_cache_disabled = false
     @request_id_to_interception_id = {}
+    @internal_network_condition = InternalNetworkCondition.new(@client)
 
     @client.on_event('Fetch.requestPaused') do |event|
       handle_request_paused(event)
@@ -94,21 +133,23 @@ class Puppeteer::NetworkManager
 
   # @param value [TrueClass|FalseClass]
   def offline_mode=(value)
-    return if @offline == value
-    @offline = value
-    @client.send_message('Network.emulateNetworkConditions',
-      offline: @offline,
-      # values of 0 remove any active throttling. crbug.com/456324#c9
-      latency: 0,
-      downloadThroughput: -1,
-      uploadThroughput: -1,
-    )
+    @internal_network_condition.offline_mode=(value)
+  end
+
+  # @param network_condition [Puppeteer::NetworkCondition|nil]
+  def emulate_network_conditions(network_condition)
+    @internal_network_condition.network_condition = network_condition
   end
 
   # @param user_agent [String]
-  def user_agent=(user_agent)
-    @client.send_message('Network.setUserAgentOverride', userAgent: user_agent)
+  # @param user_agent_metadata [Hash]
+  def set_user_agent(user_agent, user_agent_metadata = nil)
+    @client.send_message('Network.setUserAgentOverride', {
+      userAgent: user_agent,
+      userAgentMetadata: user_agent_metadata,
+    }.compact)
   end
+  alias_method :user_agent=, :set_user_agent
 
   def cache_enabled=(enabled)
     @user_cache_disabled = !enabled
@@ -210,9 +251,14 @@ class Puppeteer::NetworkManager
       end
     end
     frame = if_present(event['frameId']) { |frame_id| @frame_manager.frame(frame_id) }
-    request = Puppeteer::Request.new(@client, frame, interception_id, @user_request_interception_enabled, event, redirect_chain)
+    request = Puppeteer::HTTPRequest.new(@client, frame, interception_id, @user_request_interception_enabled, event, redirect_chain)
     @request_id_to_request[event['requestId']] = request
     emit_event(NetworkManagerEmittedEvents::Request, request)
+    begin
+      request.finalize_interceptions
+    rescue => err
+      debug_puts(err)
+    end
   end
 
   private def handle_request_served_from_cache(event)
@@ -221,13 +267,13 @@ class Puppeteer::NetworkManager
     end
   end
 
-  # @param request [Puppeteer::Request]
+  # @param request [Puppeteer::HTTPRequest]
   # @param response_payload [Hash]
   private def handle_request_redirect(request, response_payload)
-    response = Puppeteer::Response.new(@client, request, response_payload)
+    response = Puppeteer::HTTPResponse.new(@client, request, response_payload)
     request.internal.response = response
     request.internal.redirect_chain << request
-    response.internal.body_loaded_promise.reject(Puppeteer::Response::Redirected.new)
+    response.internal.body_loaded_promise.reject(Puppeteer::HTTPResponse::Redirected.new)
     @request_id_to_request.delete(request.internal.request_id)
     @attempted_authentications.delete(request.internal.interception_id)
     emit_event(NetworkManagerEmittedEvents::Response, response)
@@ -240,7 +286,7 @@ class Puppeteer::NetworkManager
     # FileUpload sends a response without a matching request.
     return unless request
 
-    response = Puppeteer::Response.new(@client, request, event['response'])
+    response = Puppeteer::HTTPResponse.new(@client, request, event['response'])
     request.internal.response = response
     emit_event(NetworkManagerEmittedEvents::Response, response)
   end

data/lib/puppeteer/page/metrics.rb

@@ -0,0 +1,49 @@
+class Puppeteer::Page
+  class Metrics
+    SUPPORTED_KEYS = Set.new([
+      'Timestamp',
+      'Documents',
+      'Frames',
+      'JSEventListeners',
+      'Nodes',
+      'LayoutCount',
+      'RecalcStyleCount',
+      'LayoutDuration',
+      'RecalcStyleDuration',
+      'ScriptDuration',
+      'TaskDuration',
+      'JSHeapUsedSize',
+      'JSHeapTotalSize',
+    ]).freeze
+
+    SUPPORTED_KEYS.each do |key|
+      attr_reader key
+    end
+
+    # @param metrics_result [Hash] response for Performance.getMetrics
+    def initialize(metrics_response)
+      metrics_response.each do |metric|
+        if SUPPORTED_KEYS.include?(metric['name'])
+          instance_variable_set(:"@#{metric['name']}", metric['value'])
+        end
+      end
+    end
+
+    def [](key)
+      if SUPPORTED_KEYS.include?(key.to_s)
+        instance_variable_get(:"@#{key}")
+      else
+        raise ArgumentError.new("invalid metric key specified: #{key}")
+      end
+    end
+  end
+
+  class MetricsEvent
+    def initialize(metrics_event)
+      @title = metrics_event['title']
+      @metrics = Metrics.new(metrics_event['metrics'])
+    end
+
+    attr_reader :title, :metrics
+  end
+end

data/lib/puppeteer/page/screenshot_options.rb

@@ -15,7 +15,7 @@ class Puppeteer::Page
     # @params options [Hash]
     def initialize(options)
       if options[:type]
-        unless [:png, :jpeg].include?(options[:type].to_sym)
+        unless [:png, :jpeg, :webp].include?(options[:type].to_sym)
           raise ArgumentError.new("Unknown options.type value: #{options[:type]}")
         end
         @type = options[:type]
@@ -25,6 +25,8 @@ class Puppeteer::Page
           @type = 'png'
         elsif mime_types.include?('image/jpeg')
           @type = 'jpeg'
+        elsif mime_types.include?('image/webp')
+          @type = 'webp'
         else
           raise ArgumentError.new("Unsupported screenshot mime type resolved: #{mime_types}, path: #{options[:path]}")
         end