watir 6.16.3 → 6.19.0

data/CHANGES.md

@@ -1,3 +1,58 @@
+### 6.19.0 (2021-03-12)
+
+* Create custom Watir HTTP Client
+* Require minimum of Selenium 3.142.7
+* Add support for starting browser with :http_client and :service hashes
+* Allow inferring desired browser from Capabilities or Options if browser not specified
+* Deprecate WindowCollection#to_a method
+* Deprecate starting browser with both Capabilities and Options
+* Deprecate starting browser with both URL and Service
+* Deprecate using :desired_capabilities
+* Deprecate starting browser service keywords in top level Hash
+* Deprecate using :remote to start a browser; browser name must be specified
+* Deprecate sending unknown keywords into the top level
+* Fix bug preventing Safari Options from being recognized
+* Fix bug preventing options provided without :remote keyword from being properly recognized (#812, #870)
+* Fix bug preventing :headless from being recognized when :options specified (#692)
+
+### 6.18.0 (2021-02-26)
+
+* Implement `WindowCollection` to manage multiple `Window` objects
+* Add support for locating `Window` by `:element`
+* Deprecate locating `Window` by `:index`
+* Deprecate `Select#select_all` in favor of `#select` and an `Array`
+* Implement `Browser#switch_window` (#849)
+* Add support for `Numeric` attribute values to `Waitable`
+* Allow users to specify Selenium 4 in their projects
+* Update stale element handling behavior to match webdriver spec (#905 #909)
+* Implement `Waitable` for `ElementCollection` (#853 #857)
+* Improve performance for nested elements (#843)
+* Less strict version check for `regexp_parser` gem (thanks Pavel Lobashov)
+
+### 6.17.0 (2020-08-27)
+* Require Ruby > 2.5
+* Implement Logger#selenium= to set selenium level from Watir
+* Implement FileField#upload
+* Fix bug with staleness handling in #exist and #present? (#853 & #852)
+* Fix bug when locating elements by text with RegExp (#866 #871)
+* Implement modifiers for `Element#right_click` (thanks Lakshya Kapoor #861)
+* Updated locator code to adhere to spec on what attributes are case sensitive (#507 #856)
+* Fix locating bug when iframe is nested under another element (thanks Matthew Mazaika #885 #886)
+* Deprecate Element#scroll_into_view in favor of the new Scroll methods (#884)
+* Fix threading bugs by allowing each Browser instance its own Timer (#881)
+* Allow adjacent locators to return Input subtype when applicable (#878)
+* Removed unnecessary reference to rubyforge (thanks olleolleolle #874)
+* Removed deprecated Selenium classes (thanks joesho112358 #867)
+* Add support for :service parameter for initializing Browser
+
+### 6.16.5 (2018-12-25)
+
+* Fix bug with nested elements using scopes (#842)
+
+### 6.16.4 (2018-12-24)
+
+* Minor adjustments to support locator extensions
+
 ### 6.16.3 (2018-12-24)
 
 * Minor adjustments to support locator extensions

data/Gemfile

@@ -1,8 +1,10 @@
-source 'http://rubygems.org'
+source 'https://rubygems.org'
 
 gem 'webidl', path: File.expand_path('../webidl') if ENV['LOCAL_WEBIDL']
 
 gem 'selenium-webdriver', path: File.expand_path('../selenium/build/rb') if ENV['LOCAL_SELENIUM']
 
+gem 'ffi' if Gem.win_platform? # For selenium-webdriver on Windows
+
 # Specify your gem's dependencies in watir.gemspec
 gemspec

data/LICENSE

@@ -1,8 +1,8 @@
 (the MIT License)
 
 Copyright (c) 2009-2015 Jari Bakken
-Copyright (c) 2015-2018 Alex Rodionov, Titus Fortner
-Copyright (c) 2018 Justin Ko
+Copyright (c) 2015-2021 Alex Rodionov, Titus Fortner
+Copyright (c) 2018-2021 Justin Ko
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -3,10 +3,12 @@
 Watir Powered By Selenium!
 
 [![Gem Version](https://badge.fury.io/rb/watir.svg)](http://badge.fury.io/rb/watir)
-[![Travis Status](https://travis-ci.org/watir/watir.svg?branch=master)](https://travis-ci.org/watir/watir)
-[![AppVeyor status](https://ci.appveyor.com/api/projects/status/9vbb7pp5p4uyoott/branch/master?svg=true)](https://ci.appveyor.com/project/p0deje/watir)
+[![Unit Tests](https://github.com/watir/watir/workflows/Unit%20Tests/badge.svg)](https://github.com/watir/watir/actions?query=workflow%3A%22Unit+Tests%22)
+[![Mac Tests](https://github.com/watir/watir/workflows/Mac%20Tests/badge.svg)](https://github.com/watir/watir/actions?query=workflow%3A%22Mac+Tests%22)
+[![Windows Tests](https://github.com/watir/watir/workflows/Windows%20Tests/badge.svg)](https://github.com/watir/watir/actions?query=workflow%3A%22Windows+Tests%22)
+[![Linux Tests](https://github.com/watir/watir/workflows/Linux%20Tests/badge.svg)](https://github.com/watir/watir/actions?query=workflow%3A%22Linux+Tests%22)
 [![Code Climate](https://codeclimate.com/github/watir/watir.svg)](https://codeclimate.com/github/watir/watir)
-[![Coverage Status](https://coveralls.io/repos/github/watir/watir/badge.svg?branch=master)](https://coveralls.io/github/watir/watir?branch=master)
+[![Coverage Status](https://coveralls.io/repos/github/watir/watir/badge.svg?branch=main)](https://coveralls.io/github/watir/watir?branch=main)
 
 ## Using Watir
 
@@ -69,11 +71,11 @@ $ bundle exec rake svg:update
 
 ## Specs
 
-#### Travis CI
+#### Github Actions
 
-Watir specs are run on [Travis CI](https://travis-ci.org/watir/watir).
+Watir specs are run with [Github Actions](https://github.com/watir/watir/workflows).
 
-Watir code is tested with 2.3, 2.4 and 2.5 versions in multiple browsers and with multiple configurations.
+Watir code is tested on Linux with latest versions of supported browsers and all active Ruby versions.
 
 #### Doctests
 
@@ -95,7 +97,7 @@ to ensure all paths in their code have tests associated with them.
 
 Watir is using [Rubocop](https://github.com/rubocop-hq/rubocop) to ensure a consistent style across the
 code base. It is run with our minimum supported Ruby version (2.3) 
-We have some [established exceptions](https://github.com/watir/watir/blob/master/.rubocop.yml) 
+We have some [established exceptions](https://github.com/watir/watir/blob/main/.rubocop.yml) 
 that might need to be tweaked for new code submissions. This can be addressed in the PR as necessary.
 
 #### Statistics
@@ -107,7 +109,4 @@ on wire calls.
 
 ## Copyright
 
-Copyright (c) 2009-2015 Jari Bakken
-Copyright (c) 2015-2018 Alex Rodionov, Titus Fortner
-Copyright (c) 2018 Justin Ko
 See LICENSE for details

data/Rakefile

@@ -5,7 +5,7 @@ Bundler::GemHelper.install_tasks
 
 require 'rspec/core/rake_task'
 RSpec::Core::RakeTask.new(:spec) do |spec|
-  spec.rspec_opts = %w[--color --require fuubar --format Fuubar]
+  spec.rspec_opts = %w[--color --format doc]
   spec.pattern = 'spec/**/*_spec.rb'
   spec.exclude_pattern = 'spec/unit/**/*_spec.rb'
 end
@@ -61,7 +61,7 @@ end
 
       if extractor.errors.any?
         puts "\n\n<======================= ERRORS =======================>\n\n"
-        puts extractor.errors.join("\n" + '=' * 80 + "\n")
+        puts extractor.errors.join("\n#{'=' * 80}\n")
       end
     end
 
@@ -93,7 +93,7 @@ YARD::Rake::YardocTask.new do |task|
   task.options = %w[--debug] # this is pretty slow, so nice with some output
 end
 
-require 'yard-doctest'
+require 'yard/doctest/rake'
 YARD::Doctest::RakeTask.new do |task|
   task.doctest_opts = ['-v']
 end
@@ -115,7 +115,7 @@ namespace :changes do
 
   desc 'Print latest diff'
   task print: :differ do
-    VersionDiffer.new.print_latest(STDOUT)
+    VersionDiffer.new.print_latest($stdout)
   end
 end
 

data/lib/watir-webdriver.rb

@@ -1,2 +1,2 @@
 require 'watir'
-warn Kernel.caller.first + ': `require "watir-webdriver"` is deprecated. Please, use `require "watir"`.'
+warn "#{Kernel.caller.first}: `require 'watir-webdriver'` is deprecated. Please, use `require 'watir'`."

data/lib/watir.rb

@@ -6,6 +6,7 @@ require 'watir/legacy_wait'
 require 'watir/wait'
 require 'watir/exception'
 require 'watir/window'
+require 'watir/window_collection'
 require 'watir/has_window'
 require 'watir/adjacent'
 require 'watir/js_execution'
@@ -13,12 +14,14 @@ require 'watir/alert'
 require 'watir/js_snippets'
 require 'watir/container'
 require 'watir/cookies'
+require 'watir/http_client'
 require 'watir/capabilities'
 require 'watir/navigation'
 require 'watir/browser'
 require 'watir/screenshot'
 require 'watir/after_hooks'
 require 'watir/logger'
+require 'watir/version'
 
 module Watir
   @relaxed_locate = true
@@ -114,7 +117,6 @@ require 'watir/elements/element'
 require 'watir/elements/html_elements'
 require 'watir/elements/svg_elements'
 
-require 'watir/elements/area'
 require 'watir/elements/button'
 require 'watir/elements/cell'
 require 'watir/elements/checkbox'

data/lib/watir/adjacent.rb

@@ -113,16 +113,14 @@ module Watir
     def xpath_adjacent(opt = {})
       plural = opt.delete(:plural)
       opt[:index] ||= 0 unless plural || opt.values.any? { |e| e.is_a? Regexp }
-      klass = if !plural && opt[:tag_name]
-                Watir.element_class_for(opt[:tag_name])
-              elsif !plural
-                HTMLElement
-              elsif opt[:tag_name]
-                Object.const_get("#{Watir.element_class_for(opt[:tag_name])}Collection")
-              else
-                HTMLElementCollection
-              end
-      klass.new(self, opt)
+      if !plural
+        el = Watir.element_class_for(opt[:tag_name] || '').new(self, opt)
+        el.is_a?(Input) ? el.to_subtype : el
+      elsif opt[:tag_name]
+        Watir.const_get("#{Watir.element_class_for(opt[:tag_name])}Collection").new(self, opt)
+      else
+        HTMLElementCollection.new(self, opt)
+      end
     end
   end # Adjacent
 end # Watir

data/lib/watir/after_hooks.rb

@@ -69,8 +69,8 @@ module Watir
       return unless @after_hooks.any? && !@browser.alert.exists?
 
       each { |after_hook| after_hook.call(@browser) }
-    rescue Selenium::WebDriver::Error::NoSuchWindowError => ex
-      Watir.logger.info "Could not execute After Hooks because browser window was closed #{ex}"
+    rescue Selenium::WebDriver::Error::NoSuchWindowError => e
+      Watir.logger.info "Could not execute After Hooks because browser window was closed #{e}"
     end
 
     #
@@ -99,8 +99,8 @@ module Watir
     # @yieldparam [#call] after_hook Object responding to call
     #
 
-    def each
-      @after_hooks.each { |after_hook| yield after_hook }
+    def each(&blk)
+      @after_hooks.each { |after_hook| blk.call(after_hook) }
     end
 
     #

data/lib/watir/alert.rb

@@ -84,6 +84,7 @@ module Watir
       false
     end
     alias present? exists?
+    alias exist? exists?
 
     #
     # @api private

data/lib/watir/attribute_helper.rb

@@ -46,6 +46,8 @@ module Watir
     #  @return [$1] value of $3 property
     #
     def attribute(type, method, attr)
+      return if method_defined?(method)
+
       typed_attributes[type] << [method, attr]
       define_attribute(type, method, attr)
     end

data/lib/watir/browser.rb

@@ -11,7 +11,7 @@ module Watir
     include Exception
     include Scrolling
 
-    attr_writer :default_context, :original_window, :locator_namespace
+    attr_writer :default_context, :original_window, :locator_namespace, :timer
     attr_reader :driver, :after_hooks
     alias wd driver # ensures duck typing with Watir::Element
 
@@ -213,11 +213,11 @@ module Watir
     # @param args Arguments will be available in the given script in the 'arguments' pseudo-array
     #
 
-    def execute_script(script, *args)
+    def execute_script(script, *args, function_name: nil)
       args.map! do |e|
         e.is_a?(Element) ? e.wait_until(&:exists?).wd : e
       end
-
+      Watir.logger.info "Executing Script on Browser: #{function_name}" if function_name
       wrap_elements_in(self, @driver.execute_script(script, *args))
     end
 
@@ -300,6 +300,10 @@ module Watir
       end
     end
 
+    def timer
+      @timer ||= Wait::Timer.new
+    end
+
     private
 
     def wrap_element(scope, element)

data/lib/watir/capabilities.rb

@@ -2,18 +2,22 @@ module Watir
   class Capabilities
     attr_reader :options
 
-    def initialize(browser, options = {})
+    def initialize(browser = nil, options = {})
+      if browser.is_a?(Hash)
+        options = browser
+        browser = nil
+      end
+
       @options = options.dup
       Watir.logger.info "Creating Browser instance of #{browser} with user provided options: #{@options.inspect}"
-      @browser = if browser == :remote && @options.key?(:browser)
-                   @options.delete(:browser)
-                 elsif browser == :remote && @options.key?(:desired_capabilities)
-                   @options[:desired_capabilities].browser_name.to_sym
-                 else
-                   browser.to_sym
-                 end
-      @selenium_browser = browser == :remote || options[:url] ? :remote : browser
 
+      deprecate_options_capabilities
+      deprecate_desired_capabilities
+      deprecate_url_service if @options.key?(:service) && @options.key?(:url)
+
+      @browser = deprecate_remote(browser) || browser.nil? && infer_browser || browser.to_sym
+
+      @selenium_browser = options[:url] ? :remote : @browser
       @selenium_opts = {}
     end
 
@@ -24,15 +28,15 @@ module Watir
     private
 
     def process_arguments
-      url = @options.delete(:url)
-      @selenium_opts[:url] = url if url
-
-      create_http_client
-
-      @selenium_opts[:port] = @options.delete(:port) if @options.key?(:port)
-      @selenium_opts[:driver_opts] = @options.delete(:driver_opts) if @options.key?(:driver_opts)
       @selenium_opts[:listener] = @options.delete(:listener) if @options.key?(:listener)
 
+      if @options.key?(:url)
+        @selenium_opts[:url] = @options.delete(:url)
+      else
+        process_service(@options.delete(:service))
+      end
+
+      process_http_client
       process_browser_options
       process_capabilities
       Watir.logger.info "Creating Browser instance with Watir processed options: #{@selenium_opts.inspect}"
@@ -40,110 +44,254 @@ module Watir
       @selenium_opts
     end
 
-    def create_http_client
-      client_timeout = @options.delete(:client_timeout)
-      open_timeout = @options.delete(:open_timeout)
-      read_timeout = @options.delete(:read_timeout)
-
-      http_client = @options.delete(:http_client)
-
-      %i[open_timeout read_timeout client_timeout].each do |t|
-        next if http_client.nil? || !respond_to?(t)
-
-        msg = "You can pass #{t} value directly into Watir::Browser opt without needing to use :http_client"
-        Watir.logger.warn msg, ids: %i[http_client use_capabilities]
+    def process_http_client
+      http_client = @options.delete(:http_client) || Watir::HttpClient.new
+      if http_client.is_a?(Hash)
+        http_client = Watir::HttpClient.new(http_client)
+      elsif !http_client.is_a?(Selenium::WebDriver::Remote::Http::Common)
+        raise TypeError, ':http_client must be a Hash or a Selenium HTTP Client instance'
       end
 
-      http_client ||= Selenium::WebDriver::Remote::Http::Default.new
+      unless http_client.is_a?(Watir::HttpClient)
+        Watir.logger.warn 'Check out the new Watir::HttpClient and let us know if there are missing features you need',
+                          ids: [:watir_client]
+      end
 
-      http_client.timeout = client_timeout if client_timeout
-      http_client.open_timeout = open_timeout if open_timeout
-      http_client.read_timeout = read_timeout if read_timeout
+      process_http_client_timeouts(http_client)
       @selenium_opts[:http_client] = http_client
     end
 
-    # TODO: - this will get addressed with Capabilities Update
-    # rubocop:disable Metrics/AbcSize
-    # rubocop:disable Metrics/MethodLength
-    # rubocop:disable Metrics/PerceivedComplexity:
-    # rubocop:disable Metrics/CyclomaticComplexity::
     def process_browser_options
       browser_options = @options.delete(:options) || {}
+      process_w3c_capabilities(browser_options)
 
-      case @selenium_browser
+      case @browser
       when :chrome
-        if @options.key?(:args) || @options.key?(:switches)
-          browser_options ||= {}
-          browser_options[:args] = (@options.delete(:args) || @options.delete(:switches)).dup
-        end
-        if @options.delete(:headless)
-          browser_options ||= {}
-          browser_options[:args] ||= []
-          browser_options[:args] += ['--headless', '--disable-gpu']
-        end
-        @selenium_opts[:options] = browser_options if browser_options.is_a? Selenium::WebDriver::Chrome::Options
-        @selenium_opts[:options] ||= Selenium::WebDriver::Chrome::Options.new(browser_options)
+        process_chrome_options(browser_options)
       when :firefox
-        profile = @options.delete(:profile)
-        if browser_options.is_a? Selenium::WebDriver::Firefox::Options
-          @selenium_opts[:options] = browser_options
-          if profile
-            msg = 'Initializing Browser with both :profile and :option', ':profile as a key inside :option'
-            Watir.logger.deprecate msg, ids: [:firefox_profile]
-          end
-        end
-        if @options.delete(:headless)
-          browser_options ||= {}
-          browser_options[:args] ||= []
-          browser_options[:args] += ['--headless']
-        end
-        @selenium_opts[:options] ||= Selenium::WebDriver::Firefox::Options.new(browser_options)
-        @selenium_opts[:options].profile = profile if profile
+        process_firefox_options(browser_options)
       when :safari
-        Selenium::WebDriver::Safari.technology_preview! if @options.delete(:technology_preview)
-      when :remote
-        if @browser == :chrome && @options.delete(:headless)
-          args = @options.delete(:args) || @options.delete(:switches) || []
-          @options['chromeOptions'] = {'args' => args + ['--headless', '--disable-gpu']}
-        end
-        if @browser == :firefox && @options.delete(:headless)
-          args = @options.delete(:args) || @options.delete(:switches) || []
-          @options[Selenium::WebDriver::Firefox::Options::KEY] = {'args' => args + ['--headless']}
-        end
-        if @browser == :safari && @options.delete(:technology_preview)
-          @options['safari.options'] = {'technologyPreview' => true}
-        end
-      when :ie
-        if @options.key?(:args)
-          browser_options ||= {}
-          browser_options[:args] = @options.delete(:args).dup
-        end
-        unless browser_options.is_a? Selenium::WebDriver::IE::Options
-          ie_caps = browser_options.select { |k| Selenium::WebDriver::IE::Options::CAPABILITIES.include?(k) }
-          browser_options = Selenium::WebDriver::IE::Options.new(browser_options)
-          ie_caps.each { |k, v| browser_options.add_option(k, v) }
-        end
-        @selenium_opts[:options] = browser_options
+        process_safari_options(browser_options)
+      when :ie, :internet_explorer
+        process_ie_options(browser_options)
       end
     end
-    # rubocop:enable Metrics/AbcSize
-    # rubocop:enable Metrics/MethodLength
-    # rubocop:enable Metrics/PerceivedComplexity:
-    # rubocop:enable Metrics/CyclomaticComplexity::
 
     def process_capabilities
-      caps = @options.delete(:desired_capabilities)
+      caps = @options.delete(:capabilities)
+
+      unless @options.empty?
+        Watir.logger.deprecate('passing unrecognized arguments into Browser constructor',
+                               'appropriate keyword to nest all arguments',
+                               ids: %i[unknown_keyword capabilities],
+                               reference: 'http://watir.com/guides/capabilities.html')
+      end
 
       if caps
-        msg = 'You can pass values directly into Watir::Browser opt without needing to use :desired_capabilities'
-        Watir.logger.warn msg,
-                          ids: [:use_capabilities]
         @selenium_opts.merge!(@options)
       else
-        caps = Selenium::WebDriver::Remote::Capabilities.send @browser, @options
+        caps = Selenium::WebDriver::Remote::Capabilities.send @browser, @options.merge(@w3c_caps)
       end
 
       @selenium_opts[:desired_capabilities] = caps
     end
+
+    def deprecate_desired_capabilities
+      return unless @options.key?(:desired_capabilities)
+
+      Watir.logger.deprecate(':desired_capabilities to initialize Browser',
+                             ':capabilities or preferably :options',
+                             ids: [:desired_capabilities],
+                             reference: 'http://watir.com/guides/capabilities.html')
+      @options[:capabilities] = @options.delete(:desired_capabilities)
+    end
+
+    def deprecate_url_service
+      Watir.logger.deprecate('allowing Browser initialization with both :url & :service',
+                             'just :service',
+                             ids: [:url_service],
+                             reference: 'http://watir.com/guides/capabilities.html')
+    end
+
+    def process_http_client_timeouts(http_client)
+      deprecate_client_timeout(http_client) if @options.key? :client_timeout
+      deprecate_open_timeout(http_client) if @options.key? :open_timeout
+      deprecate_read_timeout(http_client) if @options.key? :read_timeout
+    end
+
+    def deprecate_client_timeout(http_client)
+      Watir.logger.deprecate(':client_timeout to initialize Browser',
+                             ':open_timeout and/or :read_timeout in a Hash with :http_client key',
+                             ids: [:http_client_timeout],
+                             reference: 'http://watir.com/guides/capabilities.html')
+      timeout = @options.delete(:client_timeout)
+      http_client.open_timeout = timeout
+      http_client.read_timeout = timeout
+    end
+
+    def deprecate_open_timeout(http_client)
+      Watir.logger.deprecate(':open_timeout to initialize Browser',
+                             ':open_timeout in a Hash with :http_client key',
+                             ids: %i[http_open_timeout capabilities],
+                             reference: 'http://watir.com/guides/capabilities.html')
+      http_client.open_timeout = @options.delete(:open_timeout)
+    end
+
+    def deprecate_read_timeout(http_client)
+      Watir.logger.deprecate(':read_timeout to initialize Browser',
+                             ':read_timeout in a Hash with :http_client key',
+                             ids: %i[http_read_timeout capabilities],
+                             reference: 'http://watir.com/guides/capabilities.html')
+      http_client.read_timeout = @options.delete(:read_timeout)
+    end
+
+    def process_chrome_options(browser_options)
+      @selenium_opts[:options] = browser_options if browser_options.is_a? Selenium::WebDriver::Chrome::Options
+      @selenium_opts[:options] ||= Selenium::WebDriver::Chrome::Options.new(**browser_options)
+
+      process_args
+
+      return unless @options.delete(:headless)
+
+      @selenium_opts[:options].args << '--headless'
+      @selenium_opts[:options].args << '--disable-gpu'
+    end
+
+    def process_firefox_options(browser_options)
+      @selenium_opts[:options] = browser_options if browser_options.is_a? Selenium::WebDriver::Firefox::Options
+
+      @selenium_opts[:options] ||= Selenium::WebDriver::Firefox::Options.new(**browser_options)
+      if @options.key?(:profile)
+        new = 'Initializing Browser with both :profile and :option'
+        old = ':profile as a key inside :option'
+        Watir.logger.deprecate new, old, ids: [:firefox_profile]
+
+        @selenium_opts[:options].profile = @options.delete(:profile)
+      end
+
+      @selenium_opts[:options].args << '--headless' if @options.delete(:headless)
+    end
+
+    def process_safari_options(browser_options)
+      @selenium_opts[:options] = browser_options if browser_options.is_a? Selenium::WebDriver::Safari::Options
+      @selenium_opts[:options] ||= Selenium::WebDriver::Safari::Options.new(**browser_options)
+      Selenium::WebDriver::Safari.technology_preview! if @options.delete(:technology_preview)
+    end
+
+    def process_ie_options(browser_options)
+      @selenium_opts[:options] = browser_options if browser_options.is_a? Selenium::WebDriver::IE::Options
+      @selenium_opts[:options] ||= Selenium::WebDriver::IE::Options.new(**browser_options)
+
+      process_args
+    end
+
+    def process_service(service)
+      service = deprecate_service_keywords if service.nil?
+
+      @selenium_opts[:service] = case service
+                                 when Hash
+                                   return if service.empty?
+
+                                   Selenium::WebDriver::Service.send(@browser, service)
+                                 when Selenium::WebDriver::Service
+                                   service
+                                 else
+                                   raise TypeError, "#{service} needs to be Selenium Service or Hash instance"
+                                 end
+    end
+
+    def deprecate_service_keywords
+      service = {}
+      if @options.key?(:port)
+        Watir.logger.deprecate(':port to initialize Browser',
+                               ':port in a Hash with :service key',
+                               ids: %i[port_keyword capabilities],
+                               reference: 'http://watir.com/guides/capabilities.html')
+        service[:port] = @options.delete(:port)
+      end
+      if @options.key?(:driver_opts)
+        Watir.logger.deprecate(':driver_opts to initialize Browser',
+                               ':args as Array in a Hash with :service key',
+                               ids: %i[driver_opts_keyword capabilities],
+                               reference: 'http://watir.com/guides/capabilities.html')
+        service[:args] = @options.delete(:driver_opts)
+      end
+      service
+    end
+
+    def process_args
+      args = if @options.key?(:args)
+               deprecate_args
+               @options.delete(:args)
+             elsif @options.key?(:switches)
+               deprecate_switches
+               @options.delete(:switches)
+             else
+               []
+             end
+      args.each { |arg| @selenium_opts[:options].args << arg }
+    end
+
+    def deprecate_args
+      Watir.logger.deprecate(':args to initialize Browser',
+                             ':args inside Hash with :options key',
+                             ids: %i[args_keyword capabilities],
+                             reference: 'http://watir.com/guides/capabilities.html')
+    end
+
+    def deprecate_switches
+      Watir.logger.deprecate(':switches to initialize Browser',
+                             ':switches inside Hash with :options key',
+                             ids: %i[switches_keyword capabilities],
+                             reference: 'http://watir.com/guides/capabilities.html')
+    end
+
+    def deprecate_remote(browser)
+      return unless browser == :remote
+
+      Watir.logger.deprecate(':remote to initialize Browser',
+                             'browser key along with remote url',
+                             ids: %i[remote_keyword capabilities],
+                             reference: 'http://watir.com/guides/capabilities.html')
+      infer_browser
+    end
+
+    def infer_browser
+      if @options.key?(:browser)
+        @options.delete(:browser)
+      elsif @options.key?(:capabilities)
+        @options[:capabilities].browser_name.tr(' ', '_').to_sym
+      elsif @options.key?(:options)
+        @options[:options].class.to_s.split('::')[-2].downcase.to_sym
+      else
+        :chrome
+      end
+    end
+
+    def process_w3c_capabilities(opts)
+      @w3c_caps = {}
+      return unless opts.is_a?(Hash)
+
+      w3c_keys = %i[browser_version platform_name accept_insecure_certs page_load_strategy proxy set_window_rect
+                    timeouts unhandled_prompt_behavior strict_file_interactibility]
+
+      opts.each do |key, _val|
+        next unless key.to_s.include?(':') || w3c_keys.include?(key)
+
+        @w3c_caps[key] = opts.delete(key)
+      end
+    end
+
+    def deprecate_options_capabilities
+      return unless @options.key?(:capabilities) && @options.key?(:options)
+
+      old = 'initializing Browser with both options and capabilities'
+      new = 'Hash with :options, Selenium Options instance with :options or' \
+'Selenium Capabilities instance with :capabilities'
+      Watir.logger.deprecate(old,
+                             new,
+                             ids: %i[options_capabilities capabilities],
+                             reference: 'http://watir.com/guides/capabilities.html')
+    end
   end
 end