webdrivers 4.0.0 → 5.2.0

data/lib/webdrivers/common.rb

@@ -1,11 +1,10 @@
 # frozen_string_literal: true
 
 require 'rubygems/package'
-require 'zip'
-require 'webdrivers/logger'
 require 'webdrivers/network'
 require 'webdrivers/system'
 require 'selenium-webdriver'
+require 'webdrivers/logger'
 require 'webdrivers/version'
 
 module Webdrivers
@@ -18,15 +17,24 @@ module Webdrivers
   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']).to_i
+      @cache_time ||= (ENV['WD_CACHE_TIME'] || DEFAULT_CACHE_TIME)
+      @cache_time.to_i
     end
 
     #
@@ -34,7 +42,7 @@ module Webdrivers
     #
     # @return [String]
     def install_dir
-      @install_dir || ENV['WD_INSTALL_DIR'] || File.expand_path(File.join(ENV['HOME'], '.webdrivers'))
+      @install_dir ||= ENV['WD_INSTALL_DIR'] || DEFAULT_INSTALL_DIR
     end
 
     def logger
@@ -61,7 +69,7 @@ module Webdrivers
       raise 'Webdrivers.net_http_ssl_fix is no longer available.' \
       ' Please see https://github.com/titusfortner/webdrivers#ssl_connect-errors.'
     end
-end
+  end
 
   class Common
     class << self
@@ -72,7 +80,7 @@ end
       #
       # @return [Gem::Version]
       def required_version
-        normalize_version @required_version
+        normalize_version(@required_version ||= nil)
       end
 
       #
@@ -105,17 +113,17 @@ end
       #
       # @return [String]
       def driver_path
-        File.join System.install_dir, file_name
+        File.absolute_path File.join(System.install_dir, file_name)
       end
 
       private
 
+      def download_version
+        required_version == EMPTY_VERSION ? latest_version : required_version
+      end
+
       def download_url
-        @download_url ||= if required_version == EMPTY_VERSION
-                            downloads[downloads.keys.max]
-                          else
-                            downloads[normalize_version(required_version)]
-                          end
+        @download_url ||= direct_url(download_version).tap { |url| Webdrivers.logger.debug "#{file_name} URL: #{url}" }
       end
 
       def exists?
@@ -123,11 +131,7 @@ end
       end
 
       def correct_binary?
-        current_version == if required_version == EMPTY_VERSION
-                             latest_version
-                           else
-                             normalize_version(required_version)
-                           end
+        current_version == download_version
       rescue ConnectionError, VersionError
         driver_path if sufficient_binary?
       end
@@ -141,7 +145,7 @@ end
       end
 
       def binary_version
-        version = System.call("#{driver_path} --version")
+        version = System.call(driver_path, '--version')
         Webdrivers.logger.debug "Current version of #{driver_path} is #{version}"
         version
       rescue Errno::ENOENT
@@ -149,9 +153,15 @@ end
         nil
       end
 
-      def with_cache(file_name)
-        if System.valid_cache?(file_name)
-          normalize_version System.cached_version(file_name)
+      # 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)

data/lib/webdrivers/edge_finder.rb

@@ -0,0 +1,98 @@
+# 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/microsoft/edge]
+        files = %w[microsoft-edge microsoft-edge-beta microsoft-edge-dev]
+
+        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("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

data/lib/webdrivers/edgedriver.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require 'shellwords'
+require 'webdrivers/common'
+require 'webdrivers/chromedriver'
+require 'webdrivers/edge_finder'
+
+module Webdrivers
+  class Edgedriver < Chromedriver
+    class << self
+      undef :chrome_version
+      #
+      # Returns currently installed Edge version.
+      #
+      # @return [Gem::Version]
+      def browser_version
+        normalize_version EdgeFinder.version
+      end
+
+      #
+      # Returns url with domain for calls to get this driver.
+      #
+      # @return [String]
+      def base_url
+        'https://msedgedriver.azureedge.net'
+      end
+
+      private
+
+      def latest_point_release(version)
+        # Microsoft doesn't currently provide LATEST_RELEASE_X.Y.Z - only use X
+        # but require the driver version be >= the passed in version
+        str = Network.get(URI.join(base_url, "LATEST_RELEASE_#{version.segments[0]}"))
+        latest_release = normalize_version(str.encode('ASCII-8BIT', 'UTF-16'))
+        raise VersionError unless latest_release >= version
+
+        latest_release
+      rescue NetworkError, VersionError
+        msg = failed_to_find_message(version)
+        Webdrivers.logger.debug msg
+        raise VersionError, msg
+      end
+
+      def failed_to_find_message(version)
+        msg = "Unable to find latest point release version for #{version}."
+        msg = begin
+          # str = Network.get(URI.join(base_url, 'LATEST_RELEASE'))
+          # Microsoft doesn't yet/ever support LATEST_RELEASE - Use Canary as latest
+          str = Network.get(URI.join(base_url, 'LATEST_CANARY'))
+          latest_release = normalize_version(str.encode('ASCII-8BIT', 'UTF-16'))
+          if version > latest_release
+            "#{msg} You appear to be using a non-production version of Edge."
+          else
+            msg
+          end
+        rescue NetworkError
+          "#{msg} A network issue is preventing determination of latest msedgedriver release."
+        end
+
+        "#{msg} Please set `Webdrivers::Edgedriver.required_version = <desired driver version>` "\
+        "to a known edgedriver version: Can not reach #{base_url}"
+      end
+
+      def file_name
+        System.platform == 'win' ? 'msedgedriver.exe' : 'msedgedriver'
+      end
+
+      def apple_m1_compatible?(driver_version)
+        if System.apple_m1_architecture? && driver_version >= normalize_version('87.0.669.0')
+          Webdrivers.logger.debug 'msedgedriver version is Apple M1 compatible.'
+          return true
+        end
+
+        Webdrivers.logger.debug 'msedgedriver version is NOT Apple M1 compatible. Required >= 87.0.669.0'
+        false
+      end
+
+      def driver_filename(driver_version)
+        if System.platform == 'win' || System.wsl_v1?
+          "win#{System.bitsize}" # 32 or 64-bit
+        elsif System.platform == 'linux'
+          'linux64'
+        elsif System.platform == 'mac'
+          # Determine M1 or Intel architecture
+          apple_arch = apple_m1_compatible?(driver_version) ? 'arm' : 'mac'
+          "#{apple_arch}64"
+        else
+          raise 'Failed to determine driver filename to download for your OS.'
+        end
+      end
+
+      def direct_url(driver_version)
+        "#{base_url}/#{driver_version}/edgedriver_#{driver_filename(driver_version)}.zip"
+      end
+    end
+  end
+end
+
+::Selenium::WebDriver::Edge::Service.driver_path = proc { ::Webdrivers::Edgedriver.update }

data/lib/webdrivers/geckodriver.rb

@@ -42,14 +42,6 @@ module Webdrivers
         System.platform == 'win' ? 'geckodriver.exe' : 'geckodriver'
       end
 
-      def download_url
-        @download_url ||= if required_version == EMPTY_VERSION
-                            direct_url(latest_version)
-                          else
-                            direct_url(required_version)
-                          end
-      end
-
       def direct_url(version)
         "#{base_url}/download/v#{version}/geckodriver-v#{version}-#{platform_ext}"
       end
@@ -59,7 +51,7 @@ module Webdrivers
         when 'linux'
           "linux#{System.bitsize}.tar.gz"
         when 'mac'
-          'macos.tar.gz'
+          System.apple_m1_architecture? ? 'macos-aarch64.tar.gz' : 'macos.tar.gz'
         when 'win'
           "win#{System.bitsize}.zip"
         end
@@ -68,17 +60,4 @@ module Webdrivers
   end
 end
 
-if ::Selenium::WebDriver::Service.respond_to? :driver_path=
-  ::Selenium::WebDriver::Firefox::Service.driver_path = proc { ::Webdrivers::Geckodriver.update }
-else
-  # v3.141.0 and lower
-  module Selenium
-    module WebDriver
-      module Firefox
-        def self.driver_path
-          @driver_path ||= Webdrivers::Geckodriver.update
-        end
-      end
-    end
-  end
-end
+::Selenium::WebDriver::Firefox::Service.driver_path = proc { ::Webdrivers::Geckodriver.update }

data/lib/webdrivers/iedriver.rb

@@ -34,7 +34,7 @@ module Webdrivers
       #
       # @return [String]
       def base_url
-        'https://selenium-release.storage.googleapis.com/'
+        'https://api.github.com/repos/seleniumhq/selenium/releases'
       end
 
       private
@@ -43,32 +43,26 @@ module Webdrivers
         'IEDriverServer.exe'
       end
 
+      def direct_url(version)
+        downloads[version]
+      end
+
       def downloads
-        doc = Nokogiri::XML.parse(Network.get(base_url))
-        items = doc.css('Key').collect(&:text)
-        items.select! { |item| item.include?('IEDriverServer_Win32') }
-        ds = items.each_with_object({}) do |item, hash|
-          key = normalize_version item[/([^_]+)\.zip/, 1]
-          hash[key] = "#{base_url}#{item}"
+        ds = download_manifest.each_with_object({}) do |item, hash|
+          version = normalize_version item['name'][/\.?([^_]+)\.zip/, 1]
+          hash[version] = item['browser_download_url']
         end
         Webdrivers.logger.debug "Versions now located on downloads site: #{ds.keys}"
         ds
       end
-    end
-  end
-end
 
-if ::Selenium::WebDriver::Service.respond_to? :driver_path=
-  ::Selenium::WebDriver::IE::Service.driver_path = proc { ::Webdrivers::IEdriver.update }
-else
-  # v3.141.0 and lower
-  module Selenium
-    module WebDriver
-      module IE
-        def self.driver_path
-          @driver_path ||= Webdrivers::IEdriver.update
-        end
+      def download_manifest
+        json = Network.get(base_url)
+        all_assets = JSON.parse(json).map { |release| release['assets'] }.flatten
+        all_assets.select { |asset| asset['name'].include?('IEDriverServer_Win32') }
       end
     end
   end
 end
+
+::Selenium::WebDriver::IE::Service.driver_path = proc { ::Webdrivers::IEdriver.update }

data/lib/webdrivers/logger.rb

@@ -1,11 +1,5 @@
 # frozen_string_literal: true
 
-require 'forwardable'
-require 'logger'
-
-# Code adapted from Selenium Implementation
-# https://github.com/SeleniumHQ/selenium/blob/master/rb/lib/selenium/webdriver/common/logger.rb
-
 module Webdrivers
   #
   # @example Enable full logging
@@ -18,94 +12,9 @@ module Webdrivers
   #   Webdrivers.logger.info('This is info message')
   #   Webdrivers.logger.warn('This is warning message')
   #
-  class Logger
-    extend Forwardable
-    include ::Logger::Severity
-
-    def_delegators :@logger, :debug, :debug?,
-                   :info, :info?,
-                   :warn, :warn?,
-                   :error, :error?,
-                   :fatal, :fatal?,
-                   :level
-
+  class Logger < Selenium::WebDriver::Logger
     def initialize
-      @logger = create_logger($stdout)
-    end
-
-    def output=(io)
-      # `Logger#reopen` was added in Ruby 2.3
-      if @logger.respond_to?(:reopen)
-        @logger.reopen(io)
-      else
-        @logger = create_logger(io)
-      end
-    end
-
-    #
-    # For Ruby < 2.3 compatibility
-    # Based on https://github.com/ruby/ruby/blob/ruby_2_3/lib/logger.rb#L250
-    #
-
-    def level=(severity)
-      if severity.is_a?(Integer)
-        @logger.level = severity
-      else
-        case severity.to_s.downcase
-        when 'debug'
-          @logger.level = DEBUG
-        when 'info'
-          @logger.level = INFO
-        when 'warn'
-          @logger.level = WARN
-        when 'error'
-          @logger.level = ERROR
-        when 'fatal'
-          @logger.level = FATAL
-        when 'unknown'
-          @logger.level = UNKNOWN
-        else
-          raise ArgumentError, "invalid log level: #{severity}"
-        end
-      end
-    end
-
-    #
-    # Returns IO object used by logger internally.
-    #
-    # Normally, we would have never needed it, but we want to
-    # use it as IO object for all child processes to ensure their
-    # output is redirected there.
-    #
-    # It is only used in debug level, in other cases output is suppressed.
-    #
-    # @api private
-    #
-    def io
-      @logger.instance_variable_get(:@logdev).instance_variable_get(:@dev)
-    end
-
-    #
-    # Marks code as deprecated with replacement.
-    #
-    # @param [String] old
-    # @param [String] new
-    #
-    def deprecate(old, new)
-      warn "[DEPRECATION] #{old} is deprecated. Use #{new} instead."
-    end
-
-    private
-
-    def create_logger(output)
-      logger = ::Logger.new(output)
-      logger.progname = 'Webdrivers'
-      logger.level = ($DEBUG ? DEBUG : WARN)
-      logger.formatter = proc do |severity, time, progname, msg|
-        "#{time.strftime('%F %T')} #{severity} #{progname} #{msg}\n"
-      end
-
-      logger
+      super('Webdrivers')
     end
   end
 end

data/lib/webdrivers/network.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'net/http'
+
 module Webdrivers
   #
   # @api private

data/lib/webdrivers/railtie.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require 'webdrivers'
 require 'rails'
 
 module Webdrivers

data/lib/webdrivers/system.rb

@@ -2,6 +2,13 @@
 
 require 'rubygems/package'
 require 'zip'
+require 'English'
+
+# validate zip entry sizes to avoid zip bombs
+# see https://github.com/rubyzip/rubyzip#size-validation
+# and https://github.com/rubyzip/rubyzip/pull/403 for further details
+# this will be the default in rubyzip 2.0+
+Zip.validate_entry_sizes = true
 
 module Webdrivers
   #
@@ -13,11 +20,13 @@ module Webdrivers
         max_attempts = 3
         attempts_made = 0
         delay = 0.5
-        Webdrivers.logger.debug "Deleting #{file}"
 
         begin
           attempts_made += 1
-          File.delete file if File.exist? file
+          if File.exist? file
+            Webdrivers.logger.debug "Deleting #{file}"
+            File.delete file
+          end
         rescue Errno::EACCES # Solves an intermittent file locking issue on Windows
           sleep(delay)
           retry if File.exist?(file) && attempts_made <= max_attempts
@@ -89,7 +98,7 @@ module Webdrivers
         when /tar\.bz2$/
           untarbz2_file(tempfile)
         when /\.zip$/
-          unzip_file(tempfile)
+          unzip_file(tempfile, File.basename(target))
         else
           Webdrivers.logger.debug 'No Decompression needed'
           FileUtils.cp(tempfile, File.join(Dir.pwd, file_name))
@@ -114,19 +123,17 @@ module Webdrivers
         end
       end
 
-      def unzip_file(filename)
+      def unzip_file(filename, driver_name)
         Webdrivers.logger.debug "Decompressing #{filename}"
 
         Zip::File.open(filename) do |zip_file|
-          zip_file.each do |f|
-            @top_path ||= f.name
-            f_path = File.join(Dir.pwd, f.name)
-            delete(f_path)
-            FileUtils.mkdir_p(File.dirname(f_path)) unless File.exist?(File.dirname(f_path))
-            zip_file.extract(f, f_path)
-          end
+          driver = zip_file.get_entry(driver_name)
+          f_path = File.join(Dir.pwd, driver.name)
+          delete(f_path)
+          FileUtils.mkdir_p(File.dirname(f_path)) unless File.exist?(File.dirname(f_path))
+          zip_file.extract(driver, f_path)
         end
-        @top_path
+        driver_name
       end
 
       def platform
@@ -141,13 +148,49 @@ module Webdrivers
         end
       end
 
+      def apple_m1_architecture?
+        if platform == 'mac' && RUBY_PLATFORM.include?('arm64-darwin')
+          Webdrivers.logger.debug 'Apple architecture: M1 (arm64-darwin)'
+          return true
+        end
+
+        Webdrivers.logger.debug 'Apple architecture: Intel (mac64)'
+        false
+      end
+
+      # @return [TrueClass, FalseClass]
+      def wsl_v1?
+        platform == 'linux' && File.open('/proc/version').read.include?('Microsoft')
+      end
+
+      # @param [String] path
+      # @return [String]
+      def to_win32_path(path)
+        return path if /[a-z]:\\/iu.match?(path)
+
+        call("wslpath -w '#{path}'").chomp
+      end
+
+      # @param [String] path
+      # @return [String]
+      def to_wsl_path(path)
+        call("wslpath -u '#{path}'").chomp
+      end
+
       def bitsize
         Selenium::WebDriver::Platform.bitsize
       end
 
-      def call(cmd)
+      def call(process, arg = nil)
+        cmd = arg ? [process, arg] : process # Windows provides powershell command (process) only, no args.
         Webdrivers.logger.debug "making System call: #{cmd}"
-        `#{cmd}`
+        p = IO.popen(cmd)
+        out = p.read
+        p.close
+        raise "Failed to make system call: #{cmd}" unless $CHILD_STATUS.success?
+
+        Webdrivers.logger.debug "System call returned: #{out}"
+        out
       end
     end
   end

data/lib/webdrivers/tasks/chromedriver.rake

@@ -19,8 +19,6 @@ namespace :webdrivers do
     desc 'Remove and download updated chromedriver if necessary'
     task :update, [:version] do |_, args|
       args.with_defaults(version: 0)
-      Webdrivers.cache_time                     = ENV.fetch('WD_CACHE_TIME', 86_400)
-      Webdrivers.install_dir                    = ENV.fetch('WD_INSTALL_DIR', nil)
       Webdrivers::Chromedriver.required_version = args.version
       Webdrivers::Chromedriver.update
       Webdrivers.logger.info "Updated to chromedriver #{Webdrivers::Chromedriver.current_version}"