webdrivers 2.3.2 → 4.7.0

data/lib/webdrivers/edgedriver.rb

@@ -1,34 +1,104 @@
-require 'nokogiri'
+# frozen_string_literal: true
 
-module Webdrivers
-  class Edgedriver < Common
+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://developer.microsoft.com/en-us/microsoft-edge/tools/webdriver/'
+        '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
-        "MicrosoftWebDriver.exe"
+        System.platform == 'win' ? 'msedgedriver.exe' : 'msedgedriver'
       end
 
-      def current_version
-        # No version information available
+      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 newest_version
-        version = %x(ver)
-        version[/\d+\.\d+\.\d+/][/[^\.]\d+$/]
+      def linux_compatible?(driver_version)
+        System.platform == 'linux' && driver_version >= normalize_version('89.0.731.0')
       end
 
-      def download_url(version = nil)
-        if newest_version.to_i >= 14965
-          'https://download.microsoft.com/download/1/4/1/14156DA0-D40F-460A-B14D-1B264CA081A5/MicrosoftWebDriver.exe'
+      def driver_filename(driver_version)
+        if System.platform == 'win' || System.wsl_v1?
+          "win#{System.bitsize}" # 32 or 64-bit
+        elsif linux_compatible?(driver_version)
+          'linux64'
+        elsif System.platform == 'mac'
+          # Determine M1 or Intel architecture
+          apple_arch = apple_m1_compatible?(driver_version) ? 'arm' : 'mac'
+          "#{apple_arch}64"
         else
-          'https://download.microsoft.com/download/3/2/D/32D3E464-F2EF-490F-841B-05D53C848D15/MicrosoftWebDriver.exe'
+          raise 'Failed to determine driver filename to download for your OS.'
         end
       end
 
-      def base_url
-        'http://google.com'
+      def direct_url(driver_version)
+        "#{base_url}/#{driver_version}/edgedriver_#{driver_filename(driver_version)}.zip"
       end
     end
-
   end
-end
+end
+
+::Selenium::WebDriver::Edge::Service.driver_path = proc { ::Webdrivers::Edgedriver.update }

data/lib/webdrivers/geckodriver.rb

@@ -1,42 +1,63 @@
+# frozen_string_literal: true
+
 require 'nokogiri'
+require 'webdrivers/common'
 
 module Webdrivers
   class Geckodriver < Common
-
     class << self
-      def file_name
-        platform == "win" ? "geckodriver.exe" : "geckodriver"
-      end
-
+      #
+      # Returns current geckodriver version.
+      #
+      # @return [Gem::Version]
       def current_version
-        return nil unless File.exists?(binary_path)
-        %x(#{binary_path} --version).match(/geckodriver (\d\.\d+\.\d+)/)[1]
-      end
+        Webdrivers.logger.debug 'Checking current version'
+        return nil unless exists?
 
-      def newest_version
-        padded = downloads.keys.each_with_object({}) do |version, hash|
-          matched = version.match(/^(\d+)\.(\d+)\.(\d+)$/)
-          minor = sprintf '%02d', matched[2]
-          hash["#{matched[1]}.#{minor}.#{matched[3]}"] = version
-        end
-        padded.keys.sort.last
+        version = binary_version
+        return nil if version.nil?
+
+        normalize_version version.match(/geckodriver (\d+\.\d+\.\d+)/)[1]
       end
 
-      def downloads
-        doc = Nokogiri::XML.parse(OpenURI.open_uri(base_url))
-        items = doc.css(".release-downloads a").collect {|item| item["href"]}
-        items.reject! {|item| item.include?('archive')}
-        items.select! {|item| item.include?(platform)}
-        items.each_with_object({}) do |item, hash|
-          hash[item[/v(\d+\.\d+\.\d+)/, 1]] = "https://github.com#{item}"
-        end
+      #
+      # Returns latest available geckodriver version.
+      #
+      # @return [Gem::Version]
+      def latest_version
+        @latest_version ||= with_cache(file_name) { normalize_version(Network.get_url("#{base_url}/latest")[/[^v]*$/]) }
       end
 
+      #
+      # Returns url with domain for calls to get this driver.
+      #
+      # @return [String]
       def base_url
         'https://github.com/mozilla/geckodriver/releases'
       end
 
-    end
+      private
 
+      def file_name
+        System.platform == 'win' ? 'geckodriver.exe' : 'geckodriver'
+      end
+
+      def direct_url(version)
+        "#{base_url}/download/v#{version}/geckodriver-v#{version}-#{platform_ext}"
+      end
+
+      def platform_ext
+        case System.platform
+        when 'linux'
+          "linux#{System.bitsize}.tar.gz"
+        when 'mac'
+          'macos.tar.gz'
+        when 'win'
+          "win#{System.bitsize}.zip"
+        end
+      end
+    end
   end
-end
+end
+
+::Selenium::WebDriver::Firefox::Service.driver_path = proc { ::Webdrivers::Geckodriver.update }

data/lib/webdrivers/iedriver.rb

@@ -1,35 +1,68 @@
+# frozen_string_literal: true
+
 require 'nokogiri'
+require 'rubygems/version'
+require 'webdrivers/common'
 
 module Webdrivers
-  class IEDriver < Common
-
+  class IEdriver < Common
     class << self
-      def file_name
-        "IEDriverServer.exe"
+      #
+      # Returns current IEDriverServer.exe 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?
+
+        normalize_version version.match(/IEDriverServer.exe (\d\.\d+\.\d+)/)[1]
       end
 
-      def current_version
-        return nil unless File.exists?(binary_path)
-        %x(#{binary_path} --version).strip.match(/IEDriverServer.exe (\d\.\d+\.\d*\.\d*)/)[1]
+      #
+      # Returns latest available IEDriverServer.exe version.
+      #
+      # @return [Gem::Version]
+      def latest_version
+        @latest_version ||= with_cache(file_name) { downloads.keys.max }
       end
 
-      def newest_version
-        downloads.keys.sort.last
+      #
+      # Returns url with domain for calls to get this driver.
+      #
+      # @return [String]
+      def base_url
+        'https://api.github.com/repos/seleniumhq/selenium/releases'
+      end
+
+      private
+
+      def file_name
+        'IEDriverServer.exe'
+      end
+
+      def direct_url(version)
+        downloads[version]
       end
 
       def downloads
-        doc = Nokogiri::XML.parse(OpenURI.open_uri(base_url))
-        items = doc.css("Key").collect(&:text)
-        items.select! { |item| item.include?('IEDriverServer_Win32') }
-        items.each_with_object({}) do |item, hash|
-          hash[item[/^[^\/]+/]] = "#{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
 
-      def base_url
-        'http://selenium-release.storage.googleapis.com/'
+      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
+end
+
+::Selenium::WebDriver::IE::Service.driver_path = proc { ::Webdrivers::IEdriver.update }

data/lib/webdrivers/logger.rb

@@ -0,0 +1,111 @@
+# 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
+  #   Webdrivers.logger.level = :debug
+  #
+  # @example Log to file
+  #   Webdrivers.logger.output = 'webdrivers.log'
+  #
+  # @example Use logger manually
+  #   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
+
+    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
+    end
+  end
+end

data/lib/webdrivers/network.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require 'net/http'
+
+module Webdrivers
+  #
+  # @api private
+  #
+  class Network
+    class << self
+      def get(url, limit = 10)
+        Webdrivers.logger.debug "Making network call to #{url}"
+
+        response = get_response(url, limit)
+        case response
+        when Net::HTTPSuccess
+          response.body
+        else
+          raise NetworkError, "#{response.class::EXCEPTION_TYPE}: #{response.code} \"#{response.message}\" with #{url}"
+        end
+      end
+
+      def get_url(url, limit = 10)
+        Webdrivers.logger.debug "Making network call to #{url}"
+
+        get_response(url, limit).uri.to_s
+      end
+
+      def get_response(url, limit = 10)
+        raise ConnectionError, 'Too many HTTP redirects' if limit.zero?
+
+        begin
+          response = http.get_response(URI(url))
+        rescue SocketError
+          raise ConnectionError, "Can not reach #{url}"
+        end
+
+        Webdrivers.logger.debug "Get response: #{response.inspect}"
+
+        if response.is_a?(Net::HTTPRedirection)
+          location = response['location']
+          Webdrivers.logger.debug "Redirected to #{location}"
+          get_response(location, limit - 1)
+        else
+          response
+        end
+      end
+
+      def http
+        if using_proxy
+          Net::HTTP.Proxy(Webdrivers.proxy_addr, Webdrivers.proxy_port,
+                          Webdrivers.proxy_user, Webdrivers.proxy_pass)
+        else
+          Net::HTTP
+        end
+      end
+
+      def using_proxy
+        Webdrivers.proxy_addr && Webdrivers.proxy_port
+      end
+    end
+  end
+end

data/lib/webdrivers/railtie.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'webdrivers'
+require 'rails'
+
+module Webdrivers
+  class Railtie < Rails::Railtie
+    railtie_name :webdrivers
+
+    rake_tasks do
+      path = File.expand_path(__dir__)
+      Dir.glob("#{path}/tasks/*.rake").each { |f| load f }
+    end
+  end
+end

data/lib/webdrivers/system.rb

@@ -0,0 +1,197 @@
+# frozen_string_literal: true
+
+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
+  #
+  # @api private
+  #
+  class System
+    class << self
+      def delete(file)
+        max_attempts = 3
+        attempts_made = 0
+        delay = 0.5
+
+        begin
+          attempts_made += 1
+          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
+          raise
+        end
+      end
+
+      def install_dir
+        Webdrivers.install_dir
+      end
+
+      def cache_version(file_name, version)
+        FileUtils.mkdir_p(install_dir) unless File.exist?(install_dir)
+
+        File.open("#{install_dir}/#{file_name.gsub('.exe', '')}.version", 'w+') do |file|
+          file.print(version)
+        end
+      end
+
+      def cached_version(file_name)
+        File.open("#{install_dir}/#{file_name.gsub('.exe', '')}.version", 'r', &:read)
+      end
+
+      def valid_cache?(file_name)
+        file = "#{install_dir}/#{file_name.gsub('.exe', '')}.version"
+        return false unless File.exist?(file)
+
+        Time.now - File.mtime(file) < Webdrivers.cache_time
+      end
+
+      def download(url, target)
+        FileUtils.mkdir_p(install_dir) unless File.exist?(install_dir)
+
+        download_file(url, target)
+
+        FileUtils.chmod 'ugo+rx', target
+        Webdrivers.logger.debug "Completed download and processing of #{target}"
+        target
+      end
+
+      def download_file(url, target)
+        file_name = File.basename(url)
+        Dir.chdir(install_dir) do
+          tempfile = Tempfile.open(['', file_name], binmode: true) do |file|
+            file.print Network.get(url)
+            file
+          end
+
+          raise "Could not download #{url}" unless File.exist?(tempfile.to_path)
+
+          Webdrivers.logger.debug "Successfully downloaded #{tempfile.to_path}"
+
+          decompress_file(tempfile, file_name, target)
+          tempfile.close!
+        end
+      end
+
+      def exists?(file)
+        result = File.exist? file
+        Webdrivers.logger.debug "#{file} is#{' not' unless result} already downloaded"
+        result
+      end
+
+      def decompress_file(tempfile, file_name, target)
+        tempfile = tempfile.to_path
+        case tempfile
+        when /tar\.gz$/
+          untargz_file(tempfile, File.basename(target))
+        when /tar\.bz2$/
+          untarbz2_file(tempfile)
+        when /\.zip$/
+          unzip_file(tempfile, File.basename(target))
+        else
+          Webdrivers.logger.debug 'No Decompression needed'
+          FileUtils.cp(tempfile, File.join(Dir.pwd, file_name))
+        end
+        raise "Could not decompress #{file_name} to get #{target}" unless File.exist?(File.basename(target))
+      end
+
+      def untarbz2_file(filename)
+        Webdrivers.logger.debug "Decompressing #{filename}"
+
+        call("tar xjf #{filename}").gsub('.tar.bz2', '')
+      end
+
+      def untargz_file(source, target)
+        Webdrivers.logger.debug "Decompressing #{source}"
+
+        tar_extract = Gem::Package::TarReader.new(Zlib::GzipReader.open(source))
+
+        File.open(target, 'w+b') do |ucf|
+          tar_extract.each { |entry| ucf << entry.read }
+          File.basename ucf
+        end
+      end
+
+      def unzip_file(filename, driver_name)
+        Webdrivers.logger.debug "Decompressing #{filename}"
+
+        Zip::File.open(filename) do |zip_file|
+          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
+        driver_name
+      end
+
+      def platform
+        if Selenium::WebDriver::Platform.linux?
+          'linux'
+        elsif Selenium::WebDriver::Platform.mac?
+          'mac'
+        elsif Selenium::WebDriver::Platform.windows?
+          'win'
+        else
+          raise NotImplementedError, 'Your OS is not supported by webdrivers gem.'
+        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(process, arg = nil)
+        cmd = arg ? [process, arg] : process # Windows provides powershell command (process) only, no args.
+        Webdrivers.logger.debug "making System call: #{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
+end