ferrum 0.11 → 0.13

data/lib/ferrum/browser/options/firefox.rb

@@ -2,28 +2,32 @@
 
 module Ferrum
   class Browser
-    module Options
+    class Options
       class Firefox < Base
         DEFAULT_OPTIONS = {
-          "headless" => nil,
+          "headless" => nil
         }.freeze
 
         MAC_BIN_PATH = [
           "/Applications/Firefox.app/Contents/MacOS/firefox-bin"
         ].freeze
         LINUX_BIN_PATH = %w[firefox].freeze
+        WINDOWS_BIN_PATH = [
+          "C:/Program Files/Firefox Developer Edition/firefox.exe",
+          "C:/Program Files/Mozilla Firefox/firefox.exe"
+        ].freeze
+        PLATFORM_PATH = {
+          mac: MAC_BIN_PATH,
+          windows: WINDOWS_BIN_PATH,
+          linux: LINUX_BIN_PATH
+        }.freeze
 
         def merge_required(flags, options, user_data_dir)
-          port = options.fetch(:port, BROWSER_PORT)
-          host = options.fetch(:host, BROWSER_HOST)
-          flags.merge("remote-debugger" => "#{host}:#{port}",
-                      "profile" => user_data_dir)
+          flags.merge("remote-debugger" => "#{options.host}:#{options.port}", "profile" => user_data_dir)
         end
 
         def merge_default(flags, options)
-          unless options.fetch(:headless, true)
-            defaults = except("headless")
-          end
+          defaults = except("headless") unless options.headless
 
           defaults ||= DEFAULT_OPTIONS
           defaults.merge(flags)

data/lib/ferrum/browser/options.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Ferrum
+  class Browser
+    class Options
+      HEADLESS = true
+      BROWSER_PORT = "0"
+      BROWSER_HOST = "127.0.0.1"
+      WINDOW_SIZE = [1024, 768].freeze
+      BASE_URL_SCHEMA = %w[http https].freeze
+      DEFAULT_TIMEOUT = ENV.fetch("FERRUM_DEFAULT_TIMEOUT", 5).to_i
+      PROCESS_TIMEOUT = ENV.fetch("FERRUM_PROCESS_TIMEOUT", 10).to_i
+      DEBUG_MODE = !ENV.fetch("FERRUM_DEBUG", nil).nil?
+
+      attr_reader :window_size, :timeout, :logger, :ws_max_receive_size,
+                  :js_errors, :base_url, :slowmo, :pending_connection_errors,
+                  :url, :env, :process_timeout, :browser_name, :browser_path,
+                  :save_path, :extensions, :proxy, :port, :host, :headless,
+                  :ignore_default_browser_options, :browser_options, :xvfb
+
+      def initialize(options = nil)
+        @options = Hash(options&.dup)
+        @port = @options.fetch(:port, BROWSER_PORT)
+        @host = @options.fetch(:host, BROWSER_HOST)
+        @timeout = @options.fetch(:timeout, DEFAULT_TIMEOUT)
+        @window_size = @options.fetch(:window_size, WINDOW_SIZE)
+        @js_errors = @options.fetch(:js_errors, false)
+        @headless = @options.fetch(:headless, HEADLESS)
+        @pending_connection_errors = @options.fetch(:pending_connection_errors, true)
+        @process_timeout = @options.fetch(:process_timeout, PROCESS_TIMEOUT)
+        @browser_options = @options.fetch(:browser_options, {})
+        @slowmo = @options[:slowmo].to_f
+
+        @ws_max_receive_size, @env, @browser_name, @browser_path,
+          @save_path, @extensions, @ignore_default_browser_options, @xvfb = @options.values_at(
+            :ws_max_receive_size, :env, :browser_name, :browser_path, :save_path, :extensions,
+            :ignore_default_browser_options, :xvfb
+          )
+
+        @options[:window_size] = @window_size
+        @proxy = parse_proxy(@options[:proxy])
+        @logger = parse_logger(@options[:logger])
+        @base_url = parse_base_url(@options[:base_url]) if @options[:base_url]
+        @url = @options[:url].to_s if @options[:url]
+
+        @options.freeze
+        @browser_options.freeze
+      end
+
+      def to_h
+        @options
+      end
+
+      def parse_base_url(value)
+        parsed = Addressable::URI.parse(value)
+        unless BASE_URL_SCHEMA.include?(parsed&.normalized_scheme)
+          raise ArgumentError, "`base_url` should be absolute and include schema: #{BASE_URL_SCHEMA.join(' | ')}"
+        end
+
+        parsed
+      end
+
+      def parse_proxy(options)
+        return unless options
+
+        raise ArgumentError, "proxy options must be a Hash" unless options.is_a?(Hash)
+
+        if options[:host].nil? && options[:port].nil?
+          raise ArgumentError, "proxy options must be a Hash with at least :host | :port"
+        end
+
+        options
+      end
+
+      private
+
+      def parse_logger(logger)
+        return logger if logger
+
+        !logger && DEBUG_MODE ? $stdout.tap { |s| s.sync = true } : logger
+      end
+    end
+  end
+end

data/lib/ferrum/browser/process.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "cliver"
 require "net/http"
 require "json"
 require "addressable"
@@ -16,13 +15,11 @@ module Ferrum
     class Process
       KILL_TIMEOUT = 2
       WAIT_KILLED = 0.05
-      PROCESS_TIMEOUT = ENV.fetch("FERRUM_PROCESS_TIMEOUT", 10).to_i
 
       attr_reader :host, :port, :ws_url, :pid, :command,
                   :default_user_agent, :browser_version, :protocol_version,
                   :v8_version, :webkit_version, :xvfb
 
-
       extend Forwardable
       delegate path: :command
 
@@ -32,41 +29,50 @@ module Ferrum
 
       def self.process_killer(pid)
         proc do
-          begin
-            if Ferrum.windows?
+          if Utils::Platform.windows?
+            # Process.kill is unreliable on Windows
+            ::Process.kill("KILL", pid) unless system("taskkill /f /t /pid #{pid} >NUL 2>NUL")
+          else
+            ::Process.kill("USR1", pid)
+            start = Utils::ElapsedTime.monotonic_time
+            while ::Process.wait(pid, ::Process::WNOHANG).nil?
+              sleep(WAIT_KILLED)
+              next unless Utils::ElapsedTime.timeout?(start, KILL_TIMEOUT)
+
               ::Process.kill("KILL", pid)
-            else
-              ::Process.kill("USR1", pid)
-              start = Ferrum.monotonic_time
-              while ::Process.wait(pid, ::Process::WNOHANG).nil?
-                sleep(WAIT_KILLED)
-                next unless Ferrum.timeout?(start, KILL_TIMEOUT)
-                ::Process.kill("KILL", pid)
-                ::Process.wait(pid)
-                break
-              end
+              ::Process.wait(pid)
+              break
             end
-          rescue Errno::ESRCH, Errno::ECHILD
           end
+        rescue Errno::ESRCH, Errno::ECHILD
+          # nop
         end
       end
 
       def self.directory_remover(path)
-        proc { FileUtils.remove_entry(path) rescue Errno::ENOENT }
+        proc {
+          begin
+            FileUtils.remove_entry(path)
+          rescue StandardError
+            Errno::ENOENT
+          end
+        }
       end
 
       def initialize(options)
-        if options[:url]
-          url = URI.join(options[:url].to_s, "/json/version")
+        @pid = @xvfb = @user_data_dir = nil
+
+        if options.url
+          url = URI.join(options.url, "/json/version")
           response = JSON.parse(::Net::HTTP.get(url))
-          set_ws_url(response["webSocketDebuggerUrl"])
+          self.ws_url = response["webSocketDebuggerUrl"]
           parse_browser_versions
           return
         end
 
-        @pid = @xvfb = @user_data_dir = nil
-        @logger = options[:logger]
-        @process_timeout = options.fetch(:process_timeout, PROCESS_TIMEOUT)
+        @logger = options.logger
+        @process_timeout = options.process_timeout
+        @env = Hash(options.env)
 
         tmpdir = Dir.mktmpdir("ferrum_user_data_dir_")
         ObjectSpace.define_finalizer(self, self.class.directory_remover(tmpdir))
@@ -81,7 +87,7 @@ module Ferrum
         begin
           read_io, write_io = IO.pipe
           process_options = { in: File::NULL }
-          process_options[:pgroup] = true unless Ferrum.windows?
+          process_options[:pgroup] = true unless Utils::Platform.windows?
           process_options[:out] = process_options[:err] = write_io
 
           if @command.xvfb?
@@ -89,7 +95,8 @@ module Ferrum
             ObjectSpace.define_finalizer(self, self.class.process_killer(@xvfb.pid))
           end
 
-          @pid = ::Process.spawn(Hash(@xvfb&.to_env), *@command.to_a, process_options)
+          env = Hash(@xvfb&.to_env).merge(@env)
+          @pid = ::Process.spawn(env, *@command.to_a, process_options)
           ObjectSpace.define_finalizer(self, self.class.process_killer(@pid))
 
           parse_ws_url(read_io, @process_timeout)
@@ -128,29 +135,29 @@ module Ferrum
 
       def parse_ws_url(read_io, timeout)
         output = ""
-        start = Ferrum.monotonic_time
+        start = Utils::ElapsedTime.monotonic_time
         max_time = start + timeout
-        regexp = /DevTools listening on (ws:\/\/.*)/
-        while (now = Ferrum.monotonic_time) < max_time
+        regexp = %r{DevTools listening on (ws://.*)}
+        while (now = Utils::ElapsedTime.monotonic_time) < max_time
           begin
             output += read_io.read_nonblock(512)
           rescue IO::WaitReadable
-            IO.select([read_io], nil, nil, max_time - now)
+            read_io.wait_readable(max_time - now)
           else
             if output.match(regexp)
-              set_ws_url(output.match(regexp)[1].strip)
+              self.ws_url = output.match(regexp)[1].strip
               break
             end
           end
         end
 
-        unless ws_url
-          @logger.puts(output) if @logger
-          raise ProcessTimeoutError.new(timeout, output)
-        end
+        return if ws_url
+
+        @logger&.puts(output)
+        raise ProcessTimeoutError.new(timeout, output)
       end
 
-      def set_ws_url(url)
+      def ws_url=(url)
         @ws_url = Addressable::URI.parse(url)
         @host = @ws_url.host
         @port = @ws_url.port
@@ -171,11 +178,9 @@ module Ferrum
 
       def close_io(*ios)
         ios.each do |io|
-          begin
-            io.close unless io.closed?
-          rescue IOError
-            raise unless RUBY_ENGINE == "jruby"
-          end
+          io.close unless io.closed?
+        rescue IOError
+          raise unless RUBY_ENGINE == "jruby"
         end
       end
     end

data/lib/ferrum/browser/subscriber.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "concurrent-ruby"
-
 module Ferrum
   class Browser
     class Subscriber
@@ -29,7 +27,7 @@ module Ferrum
         method, params = message.values_at("method", "params")
         total = @on[method].size
         @on[method].each_with_index do |block, index|
-          # If there are a few callback we provide current index and total
+          # In case of multiple callbacks we provide current index and total
           block.call(params, index, total)
         end
       end

data/lib/ferrum/browser/version_info.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Ferrum
+  class Browser
+    #
+    # The browser's version information returned by [Browser.getVersion].
+    #
+    # [Browser.getVersion]: https://chromedevtools.github.io/devtools-protocol/1-3/Browser/#method-getVersion
+    #
+    # @since 0.13
+    #
+    class VersionInfo
+      #
+      # Initializes the browser's version information.
+      #
+      # @param [Hash{String => Object}] properties
+      #   The object properties returned by [Browser.getVersion](https://chromedevtools.github.io/devtools-protocol/1-3/Browser/#method-getVersion).
+      #
+      # @api private
+      #
+      def initialize(properties)
+        @properties = properties
+      end
+
+      #
+      # The Chrome DevTools protocol version.
+      #
+      # @return [String]
+      #
+      def protocol_version
+        @properties["protocolVersion"]
+      end
+
+      #
+      # The Chrome version.
+      #
+      # @return [String]
+      #
+      def product
+        @properties["product"]
+      end
+
+      #
+      # The Chrome revision properties.
+      #
+      # @return [String]
+      #
+      def revision
+        @properties["revision"]
+      end
+
+      #
+      # The Chrome `User-Agent` string.
+      #
+      # @return [String]
+      #
+      def user_agent
+        @properties["userAgent"]
+      end
+
+      #
+      # The JavaScript engine version.
+      #
+      # @return [String]
+      #
+      def js_version
+        @properties["jsVersion"]
+      end
+    end
+  end
+end

data/lib/ferrum/browser/web_socket.rb

@@ -21,9 +21,7 @@ module Ferrum
         @driver   = ::WebSocket::Driver.client(self, max_length: max_receive_size)
         @messages = Queue.new
 
-        if SKIP_LOGGING_SCREENSHOTS
-          @screenshot_commands = Concurrent::Hash.new
-        end
+        @screenshot_commands = Concurrent::Hash.new if SKIP_LOGGING_SCREENSHOTS
 
         @driver.on(:open,    &method(:on_open))
         @driver.on(:message, &method(:on_message))
@@ -31,12 +29,13 @@ module Ferrum
 
         @thread = Thread.new do
           Thread.current.abort_on_exception = true
-          if Thread.current.respond_to?(:report_on_exception=)
-            Thread.current.report_on_exception = true
-          end
+          Thread.current.report_on_exception = true if Thread.current.respond_to?(:report_on_exception=)
 
           begin
-            while data = @sock.readpartial(512)
+            loop do
+              data = @sock.readpartial(512)
+              break unless data
+
               @driver.parse(data)
             end
           rescue EOFError, Errno::ECONNRESET, Errno::EPIPE
@@ -62,7 +61,7 @@ module Ferrum
           output.sub!(/{"data":"(.*)"}/, %("Set FERRUM_LOGGING_SCREENSHOTS=true to see screenshots in Base64"))
         end
 
-        @logger&.puts("    ◀ #{Ferrum.elapsed_time} #{output}\n")
+        @logger&.puts("    ◀ #{Utils::ElapsedTime.elapsed_time} #{output}\n")
       end
 
       def on_close(_event)
@@ -71,13 +70,11 @@ module Ferrum
       end
 
       def send_message(data)
-        if SKIP_LOGGING_SCREENSHOTS
-          @screenshot_commands[data[:id]] = true
-        end
+        @screenshot_commands[data[:id]] = true if SKIP_LOGGING_SCREENSHOTS
 
         json = data.to_json
         @driver.text(json)
-        @logger&.puts("\n\n▶ #{Ferrum.elapsed_time} #{json}")
+        @logger&.puts("\n\n▶ #{Utils::ElapsedTime.elapsed_time} #{json}")
       end
 
       def write(data)

data/lib/ferrum/browser/xvfb.rb

@@ -4,23 +4,19 @@ module Ferrum
   class Browser
     class Xvfb
       NOT_FOUND = "Could not find an executable for the Xvfb. Try to install " \
-                  "it with your package manager".freeze
+                  "it with your package manager"
 
       def self.start(*args)
         new(*args).tap(&:start)
       end
 
-      def self.xvfb_path
-        Cliver.detect("Xvfb")
-      end
-
       attr_reader :screen_size, :display_id, :pid
 
       def initialize(options)
-        @path = self.class.xvfb_path
-        raise Cliver::Dependency::NotFound.new(NOT_FOUND) unless @path
+        @path = Binary.find("Xvfb")
+        raise BinaryNotFoundError, NOT_FOUND unless @path
 
-        @screen_size = options.fetch(:window_size, [1024, 768]).join("x") + "x24"
+        @screen_size = "#{options.window_size.join('x')}x24"
         @display_id = (Time.now.to_f * 1000).to_i % 100_000_000
       end