webdrivers 3.8.1 → 3.9.0

data/lib/webdrivers/common.rb

@@ -2,219 +2,153 @@
 
 require 'rubygems/package'
 require 'zip'
+require 'webdrivers/logger'
+require 'webdrivers/network'
+require 'webdrivers/system'
+require 'selenium-webdriver'
 
 module Webdrivers
-  class Common
-    class << self
-      attr_accessor :version
+  class ConnectionError < StandardError
+  end
 
-      def update
-        unless site_available?
-          return current_version.nil? ? nil : binary
-        end
+  class VersionError < StandardError
+  end
 
-        # Newer not specified or latest not found, so use existing
-        return binary if desired_version.nil? && File.exist?(binary)
+  class << self
+    attr_accessor :proxy_addr, :proxy_port, :proxy_user, :proxy_pass, :install_dir
 
-        # Can't find desired and no existing binary
-        if desired_version.nil?
-          msg = "Unable to find the latest version of #{file_name}; try downloading manually " \
-"from #{base_url} and place in #{install_dir}"
-          raise StandardError, msg
-        end
+    attr_writer :cache_time
 
-        if correct_binary?
-          Webdrivers.logger.debug 'Expected webdriver version found'
-          return binary
-        end
+    def cache_time
+      @cache_time || 0
+    end
 
-        remove # Remove outdated exe
-        download # Fetch latest
-      end
+    def logger
+      @logger ||= Webdrivers::Logger.new
+    end
 
-      def desired_version
-        if version.is_a?(Gem::Version)
-          version
-        elsif version.nil?
-          latest_version
-        else
-          normalize_version(version)
-        end
-      end
+    def configure
+      yield self
+    end
 
-      def latest_version
-        return @latest_version if @latest_version
+    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
 
-        raise StandardError, 'Can not reach site' unless site_available?
+  class Common
+    class << self
+      attr_writer :required_version
+      attr_reader :cache_warning
 
-        @latest_version = downloads.keys.max
+      def version
+        Webdrivers.logger.deprecate("#{self.class}#version", "#{self.class}#required_version")
+        required_version
       end
 
-      def remove
-        max_attempts  = 3
-        attempts_made = 0
-        delay         = 0.5
-        Webdrivers.logger.debug "Deleting #{binary}"
-        @download_url = nil
-
-        begin
-          attempts_made += 1
-          File.delete binary if File.exist? binary
-        rescue Errno::EACCES # Solves an intermittent file locking issue on Windows
-          sleep(delay)
-          retry if File.exist?(binary) && attempts_made <= max_attempts
-          raise
-        end
+      def version=(version)
+        Webdrivers.logger.deprecate("#{self.class}#version=", "#{self.class}#required_version=")
+        self.required_version = version
       end
 
-      def download
-        raise StandardError, 'Can not reach site' unless site_available?
-
-        filename = File.basename download_url
-
-        FileUtils.mkdir_p(install_dir) unless File.exist?(install_dir)
-        Dir.chdir install_dir do
-          df = Tempfile.open(['', filename], binmode: true) do |file|
-            file.print get(download_url)
-            file
-          end
-
-          raise "Could not download #{download_url}" unless File.exist? df.to_path
-
-          Webdrivers.logger.debug "Successfully downloaded #{df.to_path}"
+      def required_version
+        normalize_version @required_version
+      end
 
-          decompress_file(df.to_path, filename)
-          Webdrivers.logger.debug 'Decompression Complete'
-          Webdrivers.logger.debug "Deleting #{df.to_path}"
-          df.close!
+      def update
+        if correct_binary?
+          Webdrivers.logger.debug 'The required webdriver version is already on the system'
+          return driver_path
         end
-        raise "Could not decompress #{download_url} to get #{binary}" unless File.exist?(binary)
 
-        FileUtils.chmod 'ugo+rx', binary
-        Webdrivers.logger.debug "Completed download and processing of #{binary}"
-        binary
+        remove
+        System.download(download_url, driver_path)
       end
 
-      def install_dir
-        Webdrivers.install_dir || File.expand_path(File.join(ENV['HOME'], '.webdrivers'))
-      end
+      def desired_version
+        old = "#{self.class}#desired_version"
+        new = "#{self.class}#required_version or #{self.class}#latest_version"
+        Webdrivers.logger.deprecate(old, new)
 
-      def binary
-        File.join install_dir, file_name
+        desired_version.version.empty? ? latest_version : normalize_version(desired_version)
       end
 
-      protected
-
-      def get(url, limit = 10)
-        raise StandardError, 'Too many HTTP redirects' if limit.zero?
+      def remove
+        @download_url = nil
+        @latest_version = nil
+        System.delete "#{System.install_dir}/#{file_name.gsub('.exe', '')}.version"
+        System.delete driver_path
+      end
 
-        response = http.get_response(URI(url))
-        Webdrivers.logger.debug "Get response: #{response.inspect}"
+      def download
+        Webdrivers.logger.deprecate('#download', '#update')
+        System.download(download_url, driver_path)
+      end
 
-        case response
-        when Net::HTTPSuccess
-          response.body
-        when Net::HTTPRedirection
-          location = response['location']
-          Webdrivers.logger.debug "Redirected to #{location}"
-          get(location, limit - 1)
-        else
-          response.value
-        end
+      def binary
+        Webdrivers.logger.deprecate('#binary', '#driver_path')
+        driver_path
       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
+      def driver_path
+        File.join System.install_dir, file_name
       end
 
       private
 
       def download_url
-        @download_url ||= downloads[desired_version]
-      end
-
-      def using_proxy
-        Webdrivers.proxy_addr && Webdrivers.proxy_port
+        @download_url ||= if required_version.version.empty?
+                            downloads[downloads.keys.max]
+                          else
+                            downloads[normalize_version(required_version)]
+                          end
       end
 
-      def downloaded?
-        result = File.exist? binary
-        Webdrivers.logger.debug "File is already downloaded: #{result}"
-        result
+      def exists?
+        System.exists? driver_path
       end
 
-      def site_available?
-        Webdrivers.logger.debug "Looking for Site: #{base_url}"
-        get(base_url)
-        Webdrivers.logger.debug "Found Site: #{base_url}"
-        true
-      rescue StandardError => e
-        Webdrivers.logger.debug e
-        false
+      def correct_binary?
+        current_version == if required_version.version.empty?
+                             latest_version
+                           else
+                             normalize_version(required_version)
+                           end
+      rescue ConnectionError
+        driver_path if sufficient_binary?
       end
 
-      def platform
-        if Selenium::WebDriver::Platform.linux?
-          "linux#{Selenium::WebDriver::Platform.bitsize}"
-        elsif Selenium::WebDriver::Platform.mac?
-          'mac'
-        else
-          'win'
-        end
+      def sufficient_binary?
+        exists?
       end
 
-      def decompress_file(filename, target)
-        case filename
-        when /tar\.gz$/
-          Webdrivers.logger.debug 'Decompressing tar'
-          untargz_file(filename)
-        when /tar\.bz2$/
-          Webdrivers.logger.debug 'Decompressing bz2'
-          system "tar xjf #{filename}"
-          filename.gsub('.tar.bz2', '')
-        when /\.zip$/
-          Webdrivers.logger.debug 'Decompressing zip'
-          unzip_file(filename)
-        else
-          Webdrivers.logger.debug 'No Decompression needed'
-          FileUtils.cp(filename, File.join(Dir.pwd, target))
-        end
+      def normalize_version(version)
+        Gem::Version.new(version&.to_s)
       end
 
-      def untargz_file(filename)
-        tar_extract = Gem::Package::TarReader.new(Zlib::GzipReader.open(filename))
-
-        File.open(file_name, 'w+b') do |ucf|
-          tar_extract.each { |entry| ucf << entry.read }
-          File.basename ucf
-        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 unzip_file(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)
-            FileUtils.rm_rf(f_path) if File.exist?(f_path)
-            FileUtils.mkdir_p(File.dirname(f_path)) unless File.exist?(File.dirname(f_path))
-            zip_file.extract(f, f_path)
+      def with_cache(file_name)
+        if System.valid_cache?(file_name)
+          normalize_version System.cached_version(file_name)
+        else
+          unless cache_warning
+            Webdrivers.logger.warn 'Driver caching is turned off in this version, but will be '\
+                                  'enabled by default in 4.x. Set the value with `Webdrivers#cache_time=` in seconds'
+            @cache_warning = true
           end
+          version = yield
+          System.cache_version(file_name, version)
+          normalize_version version
         end
-        @top_path
-      end
-
-      # Already have latest version downloaded?
-      def correct_binary?
-        desired_version == current_version && File.exist?(binary)
-      end
-
-      def normalize_version(version)
-        Gem::Version.new(version.to_s)
       end
     end
   end

data/lib/webdrivers/geckodriver.rb

@@ -1,41 +1,68 @@
 # frozen_string_literal: true
 
 require 'nokogiri'
+require 'webdrivers/common'
 
 module Webdrivers
   class Geckodriver < Common
     class << self
       def current_version
         Webdrivers.logger.debug 'Checking current version'
-        return nil unless downloaded?
+        return nil unless exists?
 
-        string = `#{binary} --version`
-        Webdrivers.logger.debug "Current version of #{binary} is #{string}"
-        normalize_version string.match(/geckodriver (\d+\.\d+\.\d+)/)[1]
-      end
+        version = binary_version
+        return nil if version.nil?
 
-      private
+        normalize_version version.match(/geckodriver (\d+\.\d+\.\d+)/)[1]
+      end
 
-      def downloads # rubocop:disable  Metrics/AbcSize
-        doc = Nokogiri::HTML.parse(get(base_url))
-        items = doc.css('.py-1 a').collect { |item| item['href'] }
-        items.reject! { |item| item.include?('archive') }
-        items.select! { |item| item.include?(platform) }
-        ds = items.each_with_object({}) do |item, hash|
-          key = normalize_version item[/v(\d+\.\d+\.\d+)/, 1]
-          hash[key] = "https://github.com#{item}"
-        end
-        Webdrivers.logger.debug "Versions now located on downloads site: #{ds.keys}"
-        ds
+      def latest_version
+        @latest_version ||= with_cache(file_name) { normalize_version(Network.get_url("#{base_url}/latest")[/[^v]*$/]) }
       end
 
+      private
+
       def file_name
-        platform == 'win' ? 'geckodriver.exe' : 'geckodriver'
+        System.platform == 'win' ? 'geckodriver.exe' : 'geckodriver'
       end
 
       def base_url
         'https://github.com/mozilla/geckodriver/releases'
       end
+
+      def download_url
+        @download_url ||= required_version.version.empty? ? direct_url(latest_version) : direct_url(required_version)
+      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
+
+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

data/lib/webdrivers/iedriver.rb

@@ -2,17 +2,23 @@
 
 require 'nokogiri'
 require 'rubygems/version'
+require 'webdrivers/common'
 
 module Webdrivers
   class IEdriver < Common
     class << self
       def current_version
         Webdrivers.logger.debug 'Checking current version'
-        return nil unless downloaded?
+        return nil unless exists?
 
-        string = `#{binary} --version`
-        Webdrivers.logger.debug "Current version of #{binary} is #{string}"
-        normalize_version string.match(/IEDriverServer.exe (\d\.\d+\.\d*\.\d*)/)[1]
+        version = binary_version
+        return nil if version.nil?
+
+        normalize_version version.match(/IEDriverServer.exe (\d\.\d+\.\d+)/)[1]
+      end
+
+      def latest_version
+        @latest_version ||= with_cache(file_name) { downloads.keys.max }
       end
 
       private
@@ -26,7 +32,7 @@ module Webdrivers
       end
 
       def downloads
-        doc = Nokogiri::XML.parse(get(base_url))
+        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|
@@ -39,3 +45,18 @@ module Webdrivers
     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
+      end
+    end
+  end
+end