webdrivers 2.3.2 → 4.7.0

data/lib/webdrivers/chrome_finder.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module Webdrivers
+  #
+  # @api private
+  #
+  class ChromeFinder
+    class << self
+      def version
+        version = send("#{System.platform}_version", location)
+        raise VersionError, 'Failed to find Chrome version.' if version.nil? || version.empty?
+
+        Webdrivers.logger.debug "Browser version: #{version}"
+        version[/\d+\.\d+\.\d+\.\d+/] # Google Chrome 73.0.3683.75 -> 73.0.3683.75
+      end
+
+      def location
+        chrome_bin = user_defined_location || send("#{System.platform}_location")
+        return chrome_bin unless chrome_bin.nil?
+
+        raise BrowserNotFound, 'Failed to find Chrome binary.'
+      end
+
+      private
+
+      def user_defined_location
+        if Selenium::WebDriver::Chrome.path
+          Webdrivers.logger.debug "Selenium::WebDriver::Chrome.path: #{Selenium::WebDriver::Chrome.path}"
+          return Selenium::WebDriver::Chrome.path
+        end
+
+        return if ENV['WD_CHROME_PATH'].nil?
+
+        Webdrivers.logger.debug "WD_CHROME_PATH: #{ENV['WD_CHROME_PATH']}"
+        ENV['WD_CHROME_PATH']
+      end
+
+      def win_location
+        envs = %w[LOCALAPPDATA PROGRAMFILES PROGRAMFILES(X86)]
+        directories = ['\\Google\\Chrome\\Application', '\\Chromium\\Application']
+        file = 'chrome.exe'
+
+        directories.each do |dir|
+          envs.each do |root|
+            option = "#{ENV[root]}\\#{dir}\\#{file}"
+            return option if File.exist?(option)
+          end
+        end
+
+        nil
+      end
+
+      def wsl_location
+        _, drive, user = ENV['PATH'].match(%r{/([a-z])/Users/([^/:]+)/AppData/}).to_a
+
+        roots = [
+          "#{drive}:\\Users\\#{user}\\AppData\\Local",
+          "#{drive}:\\Program Files (x86)",
+          "#{drive}:\\Program Files"
+        ]
+
+        directories = %w[Google\\Chrome\\Application Chromium\\Application]
+        file = 'chrome.exe'
+
+        directories.each do |dir|
+          roots.each do |root|
+            option = System.to_wsl_path("#{root}\\#{dir}\\#{file}")
+            return option if File.exist?(option)
+          end
+        end
+
+        nil
+      end
+
+      def mac_location
+        directories = ['', File.expand_path('~')]
+        files = ['/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
+                 '/Applications/Chromium.app/Contents/MacOS/Chromium']
+
+        directories.each do |dir|
+          files.each do |file|
+            option = "#{dir}/#{file}"
+            return option if File.exist?(option)
+          end
+        end
+
+        nil
+      end
+
+      def linux_location
+        return wsl_location if System.wsl_v1?
+
+        directories = %w[/usr/local/sbin /usr/local/bin /usr/sbin /usr/bin /sbin /bin /snap/bin /opt/google/chrome]
+        files = %w[google-chrome chrome chromium chromium-browser]
+
+        directories.each do |dir|
+          files.each do |file|
+            option = "#{dir}/#{file}"
+            return option if File.exist?(option)
+          end
+        end
+
+        nil
+      end
+
+      def win_version(location)
+        System.call("pwsh.exe -command \"(Get-ItemProperty '#{location}').VersionInfo.ProductVersion\"")&.strip
+      rescue StandardError
+        System.call("powershell.exe \"(Get-ItemProperty '#{location}').VersionInfo.ProductVersion\"")&.strip
+      end
+
+      def wsl_version(location)
+        win_version(System.to_win32_path(location))
+      end
+
+      def linux_version(location)
+        return wsl_version(location) if System.wsl_v1?
+
+        System.call(location, '--product-version')&.strip
+      end
+
+      def mac_version(location)
+        System.call(location, '--version')&.strip
+      end
+    end
+  end
+end

data/lib/webdrivers/chromedriver.rb

@@ -1,41 +1,149 @@
-require 'nokogiri'
+# frozen_string_literal: true
+
+require 'shellwords'
+require 'webdrivers/common'
+require 'webdrivers/chrome_finder'
 
 module Webdrivers
   class Chromedriver < Common
-
     class << self
-      def file_name
-        platform == "win" ? "chromedriver.exe" : "chromedriver"
+      #
+      # Returns current chromedriver version.
+      #
+      # @return [Gem::Version]
+      def current_version
+        Webdrivers.logger.debug 'Checking current version'
+        return nil unless exists?
+
+        version = binary_version
+        return nil if version.nil?
+
+        # Matches 2.46, 2.46.628411 and 73.0.3683.75
+        normalize_version version[/\d+\.\d+(\.\d+)?(\.\d+)?/]
       end
 
-      def current_version
-        return nil unless File.exists?(binary_path)
-        %x(#{binary_path} --version).match(/ChromeDriver (\d\.\d+)/)[1]
+      #
+      # Returns latest available chromedriver version.
+      #
+      # @return [Gem::Version]
+      def latest_version
+        @latest_version ||= begin
+          # Versions before 70 do not have a LATEST_RELEASE file
+          return normalize_version('2.41') if browser_build_version < normalize_version('70')
+
+          # Cache check
+          # Cached version should exist and be compatible with the current browser version.
+          # Otherwise, fetch the latest compatible driver.
+          latest_applicable = with_cache(file_name,
+                                         current_build_version,
+                                         browser_build_version) { latest_point_release(browser_build_version) }
+
+          Webdrivers.logger.debug "Latest version available: #{latest_applicable}"
+          normalize_version(latest_applicable)
+        end
+      end
+
+      #
+      # Returns currently installed Chrome/Chromium version.
+      #
+      # @return [Gem::Version]
+      def browser_version
+        normalize_version ChromeFinder.version
+      end
+      alias chrome_version browser_version
+
+      #
+      # Returns url with domain for calls to get this driver.
+      #
+      # @return [String]
+      def base_url
+        'https://chromedriver.storage.googleapis.com'
+      end
+
+      private
+
+      def latest_point_release(version)
+        normalize_version(Network.get(URI.join(base_url, "LATEST_RELEASE_#{version}")))
+      rescue NetworkError
+        msg = "Unable to find latest point release version for #{version}."
+        msg = begin
+          latest_release = normalize_version(Network.get(URI.join(base_url, 'LATEST_RELEASE')))
+          if version > latest_release
+            "#{msg} You appear to be using a non-production version of Chrome."
+          else
+            msg
+          end
+        rescue NetworkError
+          "#{msg} A network issue is preventing determination of latest chromedriver release."
+        end
+
+        msg = "#{msg} Please set `Webdrivers::Chromedriver.required_version = <desired driver version>` "\
+              'to a known chromedriver version: https://chromedriver.storage.googleapis.com/index.html'
+        Webdrivers.logger.debug msg
+        raise VersionError, msg
       end
 
-      def newest_version
-        padded = downloads.keys.each_with_object({}) do |version, hash|
-          matched = version.match(/^(\d+)\.(\d+)$/)
-          minor = sprintf '%02d', matched[2]
-          hash["#{matched[1]}.#{minor}"] = version
+      def file_name
+        System.platform == 'win' || System.wsl_v1? ? 'chromedriver.exe' : 'chromedriver'
+      end
+
+      def apple_m1_compatible?(driver_version)
+        if System.apple_m1_architecture? && driver_version >= normalize_version('87.0.4280.88')
+          Webdrivers.logger.debug 'chromedriver version is Apple M1 compatible.'
+          return true
         end
-        padded.keys.sort.last
+
+        Webdrivers.logger.debug 'chromedriver version is NOT Apple M1 compatible. Required >= 87.0.4280.88'
+        false
       end
 
-      def downloads
-        doc = Nokogiri::XML.parse(OpenURI.open_uri(base_url))
-        items = doc.css("Contents Key").collect(&:text)
-        items.select! { |item| item.include?(platform) }
-        items.each_with_object({}) do |item, hash|
-          hash[item[/^[^\/]+/]] = "#{base_url}/#{item}"
+      def direct_url(driver_version)
+        "#{base_url}/#{driver_version}/chromedriver_#{driver_filename(driver_version)}.zip"
+      end
+
+      def driver_filename(driver_version)
+        if System.platform == 'win' || System.wsl_v1?
+          'win32'
+        elsif System.platform == 'linux'
+          'linux64'
+        elsif System.platform == 'mac'
+          apple_arch = apple_m1_compatible?(driver_version) ? '_m1' : ''
+          "mac64#{apple_arch}"
+        else
+          raise 'Failed to determine driver filename to download for your OS.'
         end
       end
 
-      def base_url
-        'http://chromedriver.storage.googleapis.com'
+      # Returns major.minor.build version from the currently installed chromedriver version
+      #
+      # @example
+      #   73.0.3683.68 (major.minor.build.patch) -> 73.0.3683 (major.minor.build)
+      def current_build_version
+        build_ver = if current_version.nil? # Driver not found
+                      nil
+                    else
+                      current_version.segments[0..2].join('.')
+                    end
+        normalize_version(build_ver)
       end
 
-    end
+      # Returns major.minor.build version from the currently installed Chrome version
+      #
+      # @example
+      #   73.0.3683.75 (major.minor.build.patch) -> 73.0.3683 (major.minor.build)
+      def browser_build_version
+        normalize_version(browser_version.segments[0..2].join('.'))
+      end
+      alias chrome_build_version browser_build_version
 
+      # Returns true if an executable driver binary exists
+      # and its build version matches the browser build version
+      def sufficient_binary?
+        super && current_version && (current_version < normalize_version('70.0.3538') ||
+          current_build_version == browser_build_version)
+      end
+    end
   end
-end
+end
+
+::Selenium::WebDriver::Chrome::Service.driver_path = proc { ::Webdrivers::Chromedriver.update }

data/lib/webdrivers/common.rb

@@ -1,100 +1,175 @@
+# frozen_string_literal: true
+
 require 'rubygems/package'
-require 'zip'
+require 'webdrivers/logger'
+require 'webdrivers/network'
+require 'webdrivers/system'
+require 'selenium-webdriver'
+require 'webdrivers/version'
 
 module Webdrivers
-  class Common
+  class ConnectionError < StandardError
+  end
+
+  class VersionError < StandardError
+  end
+
+  class NetworkError < StandardError
+  end
+
+  class BrowserNotFound < StandardError
+  end
+
+  DEFAULT_CACHE_TIME = 86_400 # 24 hours
+  DEFAULT_INSTALL_DIR = File.expand_path('~/.webdrivers')
+
+  class << self
+    attr_accessor :proxy_addr, :proxy_port, :proxy_user, :proxy_pass
+    attr_writer :install_dir, :cache_time
+
+    #
+    # Returns the amount of time (Seconds) the gem waits between two update checks.
+    # @note Value from the environment variable "WD_CACHE_TIME" takes precedence over Webdrivers.cache_time. If neither
+    # are set, it defaults to 86,400 Seconds (24 hours).
+    #
+    def cache_time
+      @cache_time ||= (ENV['WD_CACHE_TIME'] || DEFAULT_CACHE_TIME)
+      @cache_time.to_i
+    end
+
+    #
+    # Returns the install (download) directory path for the drivers.
+    #
+    # @return [String]
+    def install_dir
+      @install_dir ||= ENV['WD_INSTALL_DIR'] || DEFAULT_INSTALL_DIR
+    end
+
+    def logger
+      @logger ||= Webdrivers::Logger.new
+    end
 
+    #
+    # Provides a convenient way to configure the gem.
+    #
+    # @example Configure proxy and cache_time
+    #   Webdrivers.configure do |config|
+    #     config.proxy_addr = 'myproxy_address.com'
+    #     config.proxy_port = '8080'
+    #     config.proxy_user = 'username'
+    #     config.proxy_pass = 'password'
+    #     config.cache_time = 604_800 # 7 days
+    #   end
+    #
+    def configure
+      yield self
+    end
+
+    def net_http_ssl_fix
+      raise 'Webdrivers.net_http_ssl_fix is no longer available.' \
+      ' Please see https://github.com/titusfortner/webdrivers#ssl_connect-errors.'
+    end
+  end
+
+  class Common
     class << self
-      def install *args
-        download
-        exec binary_path, *args
+      attr_writer :required_version
+
+      #
+      # Returns the user defined required version.
+      #
+      # @return [Gem::Version]
+      def required_version
+        normalize_version(@required_version ||= nil)
       end
 
-      def download
-        return if File.exists?(binary_path) && !internet_connection?
-        raise StandardError, "Unable to Reach #{base_url}" unless internet_connection?
-        return if newest_version == current_version
-
-        url = download_url
-        filename = File.basename url
-        Dir.chdir platform_install_dir do
-          FileUtils.rm_f filename
-          File.open(filename, "wb") do |saved_file|
-            URI.parse(url).open("rb") do |read_file|
-              saved_file.write(read_file.read)
-            end
-          end
-          raise "Could not download #{url}" unless File.exists? filename
-          dcf = decompress_file(filename)
-          extract_file(dcf) if respond_to? :extract_file
+      #
+      # Triggers an update check.
+      #
+      # @return [String] Path to the driver binary.
+      def update
+        if correct_binary?
+          msg = required_version != EMPTY_VERSION ?  'The required webdriver version' : 'A working webdriver version'
+          Webdrivers.logger.debug "#{msg} is already on the system"
+          return driver_path
         end
-        raise "Could not unzip #{filename} to get #{binary_path}" unless File.exists? binary_path
-        FileUtils.chmod "ugo+rx", binary_path
+
+        remove
+        System.download(download_url, driver_path)
       end
 
-      def decompress_file(filename)
-        case filename
-        when /tar\.gz$/
-          untargz_file(filename)
-        when /\.zip$/
-          unzip_file(filename)
-        end
+      #
+      # Deletes the existing driver binary.
+      #
+      def remove
+        @download_url = nil
+        @latest_version = nil
+        System.delete "#{System.install_dir}/#{file_name.gsub('.exe', '')}.version"
+        System.delete driver_path
+      end
+
+      #
+      # Returns path to the driver binary.
+      #
+      # @return [String]
+      def driver_path
+        File.absolute_path File.join(System.install_dir, file_name)
       end
 
-      def untargz_file(filename)
-        tar_extract = Gem::Package::TarReader.new(Zlib::GzipReader.open(filename))
-        tar_extract.rewind
+      private
 
-        ucf = File.open(file_name, "w+")
-        tar_extract.each { |entry| ucf << entry.read }
-        ucf.close
-        File.basename ucf
+      def download_version
+        required_version == EMPTY_VERSION ? latest_version : required_version
       end
 
-      def unzip_file(filename)
-        Zip::ZipFile.open("#{Dir.pwd}/#{filename}") do |zip_file|
-          zip_file.each do |f|
-            @top_path ||= f.name
-            f_path = File.join(Dir.pwd, f.name)
-            FileUtils.mkdir_p(File.dirname(f_path))
-            zip_file.extract(f, f_path) unless File.exist?(f_path)
-          end
-        end
-        @top_path
+      def download_url
+        @download_url ||= direct_url(download_version).tap { |url| Webdrivers.logger.debug "#{file_name} URL: #{url}" }
       end
 
-      def download_url(version = nil)
-        downloads[version || newest_version]
+      def exists?
+        System.exists? driver_path
       end
 
-      def binary_path
-        File.join platform_install_dir, file_name
+      def correct_binary?
+        current_version == download_version
+      rescue ConnectionError, VersionError
+        driver_path if sufficient_binary?
       end
 
-      def platform_install_dir
-        File.join(install_dir, platform).tap { |dir| FileUtils.mkdir_p dir }
+      def sufficient_binary?
+        exists?
       end
 
-      def install_dir
-        File.expand_path(File.join(ENV['HOME'], ".webdrivers")).tap { |dir| FileUtils.mkdir_p dir}
+      def normalize_version(version)
+        Gem::Version.new(version.to_s)
       end
 
-      def platform
-        cfg = RbConfig::CONFIG
-        case cfg['host_os']
-          when /linux/ then
-            cfg['host_cpu'] =~ /x86_64|amd64/ ? "linux64" : "linux32"
-          when /darwin/ then "mac"
-          else "win"
-        end
+      def binary_version
+        version = System.call(driver_path, '--version')
+        Webdrivers.logger.debug "Current version of #{driver_path} is #{version}"
+        version
+      rescue Errno::ENOENT
+        Webdrivers.logger.debug "No Such File or Directory: #{driver_path}"
+        nil
       end
 
-      def internet_connection?
-        true #if open(base_url)
-      rescue
-        false
+      # Returns cached driver version if cache is still valid and the driver binary exists.
+      # Otherwise caches the given version (typically the latest available)
+      # In case of Chrome, it also verifies that the driver build and browser build versions are compatible.
+      # Example usage: lib/webdrivers/chromedriver.rb:34
+      def with_cache(file_name, driver_build = nil, browser_build = nil)
+        if System.valid_cache?(file_name) && exists? && (driver_build == browser_build)
+          cached_version = System.cached_version(file_name)
+          Webdrivers.logger.debug "using cached version as latest: #{cached_version}"
+          normalize_version cached_version
+        else
+          version = yield
+          System.cache_version(file_name, version)
+          normalize_version version
+        end
       end
-    end
 
+      EMPTY_VERSION = Gem::Version.new('')
+    end
   end
-end
+end

data/lib/webdrivers/edge_finder.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module Webdrivers
+  #
+  # @api private
+  #
+  class EdgeFinder
+    class << self
+      def version
+        version = send("#{System.platform}_version", location)
+        raise VersionError, 'Failed to find Edge version.' if version.nil? || version.empty?
+
+        Webdrivers.logger.debug "Browser version: #{version}"
+        version[/\d+\.\d+\.\d+\.\d+/] # Microsoft Edge 73.0.3683.75 -> 73.0.3683.75
+      end
+
+      def location
+        edge_bin = user_defined_location || send("#{System.platform}_location")
+        return edge_bin unless edge_bin.nil?
+
+        raise BrowserNotFound, 'Failed to find Edge binary.'
+      end
+
+      private
+
+      def user_defined_location
+        if Selenium::WebDriver::Edge.path
+          Webdrivers.logger.debug "Selenium::WebDriver::Edge.path: #{Selenium::WebDriver::Edge.path}"
+          return Selenium::WebDriver::Edge.path
+        end
+
+        return if ENV['WD_EDGE_PATH'].nil?
+
+        Webdrivers.logger.debug "WD_EDGE_PATH: #{ENV['WD_EDGE_PATH']}"
+        ENV['WD_EDGE_PATH']
+      end
+
+      def win_location
+        envs = %w[LOCALAPPDATA PROGRAMFILES PROGRAMFILES(X86)]
+        directories = ['\\Microsoft\\Edge\\Application',
+                       '\\Microsoft\\Edge Beta\\Application',
+                       '\\Microsoft\\Edge Dev\\Application',
+                       '\\Microsoft\\Edge SxS\\Application']
+        file = 'msedge.exe'
+
+        directories.each do |dir|
+          envs.each do |root|
+            option = "#{ENV[root]}\\#{dir}\\#{file}"
+            return option if File.exist?(option)
+          end
+        end
+        nil
+      end
+
+      def mac_location
+        directories = ['', File.expand_path('~')]
+        files = ['/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge',
+                 '/Applications/Microsoft Edge Beta.app/Contents/MacOS/Microsoft Edge Beta',
+                 '/Applications/Microsoft Edge Dev.app/Contents/MacOS/Microsoft Edge Dev',
+                 '/Applications/Microsoft Edge Canary.app/Contents/MacOS/Microsoft Edge Canary']
+
+        directories.each do |dir|
+          files.each do |file|
+            option = "#{dir}/#{file}"
+            return option if File.exist?(option)
+          end
+        end
+        nil
+      end
+
+      def linux_location
+        # directories = %w[/usr/local/sbin /usr/local/bin /usr/sbin /usr/bin /sbin /bin /snap/bin /opt/google/chrome]
+        # files = %w[microsoft-edge] # Based on Microsoft Edge 89.0.760.0 dev
+        #
+        # directories.each do |dir|
+        #   files.each do |file|
+        #     option = "#{dir}/#{file}"
+        #     return option if File.exist?(option)
+        #   end
+        # end
+        #
+        # nil
+        raise 'Default location not yet known'
+      end
+
+      def win_version(location)
+        System.call("powershell (Get-ItemProperty '#{location}').VersionInfo.ProductVersion")&.strip
+      end
+
+      def linux_version(location)
+        System.call(location, '--product-version')&.strip
+      end
+
+      def mac_version(location)
+        System.call(location, '--version')&.strip
+      end
+    end
+  end
+end