watir 6.17.0 → 7.0.0.beta2

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

@@ -55,16 +55,21 @@ module Watir
       @default_context = true
     end
 
+    # rubocop:disable Metrics/AbcSize
+    # TODO: w3c default behavior does not like checking if alert exists
     def inspect
       if alert.exists?
         format('#<%s:0x%x alert=true>', self.class, hash * 2)
       else
         format('#<%s:0x%x url=%s title=%s>', self.class, hash * 2, url.inspect, title.inspect)
       end
+    rescue Selenium::WebDriver::Error::NoSuchWindowError
+      format('#<%s:0x%x closed=%s>', self.class, hash * 2, closed?)
     rescue Errno::ECONNREFUSED
       format('#<%s:0x%x closed=true>', self.class, hash * 2)
     end
     alias selector_string inspect
+    # rubocop:enable Metrics/AbcSize
 
     #
     # Returns URL of current page.
@@ -101,13 +106,23 @@ module Watir
     #
 
     def close
-      return if @closed
+      return if closed?
 
       @driver.quit
       @closed = true
     end
     alias quit close
 
+    #
+    # Returns true if browser is closed and false otherwise.
+    #
+    # @return [Boolean]
+    #
+
+    def closed?
+      @closed
+    end
+
     #
     # Handles cookies.
     #
@@ -213,11 +228,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
 
@@ -252,12 +267,12 @@ module Watir
     #
 
     def exist?
-      !@closed && window.present?
+      !closed? && window.present?
     end
     alias exists? exist?
 
     def locate
-      raise Error, 'browser was closed' if @closed
+      raise Error, 'browser was closed' if closed?
 
       ensure_context
     end
@@ -267,7 +282,6 @@ module Watir
 
       driver.switch_to.default_content
       @default_context = true
-      after_hooks.run
     end
 
     def browser

data/lib/watir/capabilities.rb

@@ -2,19 +2,23 @@ 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
-
-      @selenium_opts = {}
+
+      if @options.key?(:capabilities) && @options.key?(:options)
+        raise(ArgumentError, ':capabilities and :options are not both allowed')
+      end
+      raise(ArgumentError, ':url and :service are not both allowed') if @options.key?(:service) && @options.key?(:url)
+
+      @browser = browser.nil? && infer_browser || browser
+
+      @selenium_browser = @options.key?(:url) ? :remote : @browser
     end
 
     def to_args
@@ -24,129 +28,94 @@ module Watir
     private
 
     def process_arguments
-      url = @options.delete(:url)
-      if url
-        @selenium_opts[:url] = url
-      elsif @options.key?(:service)
-        @selenium_opts[:service] = options.delete(:service)
-      end
-
-      create_http_client
+      selenium_opts = {}
+      selenium_opts[:listener] = @options.delete(:listener) if @options.key?(:listener)
 
-      @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
+        service = process_service
+        selenium_opts[:service] = service if service
+      end
 
-      process_browser_options
-      process_capabilities
-      Watir.logger.info "Creating Browser instance with Watir processed options: #{@selenium_opts.inspect}"
+      selenium_opts[:http_client] = process_http_client
+      selenium_opts[:capabilities] = @options.delete(:capabilities) || process_browser_options
 
-      @selenium_opts
+      Watir.logger.info "Creating Browser instance with Watir processed options: #{selenium_opts.inspect}"
+      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
+
+      case http_client
+      when Hash
+        Watir::HttpClient.new(**http_client)
+      when Watir::HttpClient
+        http_client
+      when Selenium::WebDriver::Remote::Http::Common
+        Watir.logger.warn 'Check out the new Watir::HttpClient and let us know if there are missing features you need',
+                          id: [:watir_client]
+        http_client
+      else
+        raise TypeError, ':http_client must be a Hash or a Selenium HTTP Client instance'
       end
-
-      http_client ||= Selenium::WebDriver::Remote::Http::Default.new
-
-      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
-      @selenium_opts[:http_client] = http_client
     end
 
-    # TODO: - this will get addressed with Capabilities Update
-    # rubocop:disable Metrics/MethodLength
-    # rubocop:disable Metrics/PerceivedComplexity:
-    # rubocop:disable Metrics/CyclomaticComplexity::
     def process_browser_options
       browser_options = @options.delete(:options) || {}
 
-      case @selenium_browser
-      when :chrome
-        if @options.key?(:args) || @options.key?(:switches)
-          browser_options ||= {}
-          browser_options[:args] = (@options.delete(:args) || @options.delete(:switches)).dup
-        end
+      options = browser_options if browser_options.is_a? Selenium::WebDriver::Options
+      options ||= Selenium::WebDriver::Options.send(@browser, **browser_options)
+
+      browser_specific_options(options)
+      raise ArgumentError, "#{@options} are unrecognized arguments for Browser constructor" unless @options.empty?
+
+      options
+    end
+
+    def browser_specific_options(options)
+      case @browser
+      when :chrome, :edge, :microsoftedge
         if @options.delete(:headless)
-          browser_options ||= {}
-          browser_options[:args] ||= []
-          browser_options[:args] += ['--headless', '--disable-gpu']
+          options.args << '--headless'
+          options.args << '--disable-gpu'
+          options.args << '--no-sandbox'
         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)
       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
+        options.headless! if @options.delete(:headless)
       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
       end
     end
 
-    # rubocop:enable Metrics/MethodLength
-    # rubocop:enable Metrics/PerceivedComplexity:
-    # rubocop:enable Metrics/CyclomaticComplexity::
+    def process_service
+      service = @options.delete(:service)
 
-    def process_capabilities
-      caps = @options.delete(:desired_capabilities)
+      case service
+      when nil
+        nil
+      when Hash
+        return if service.empty?
 
-      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)
+        Selenium::WebDriver::Service.send(@browser, **service)
+      when Selenium::WebDriver::Service
+        service
       else
-        caps = Selenium::WebDriver::Remote::Capabilities.send @browser, @options
+        raise TypeError, "#{service} needs to be Selenium Service or Hash instance"
       end
+    end
 
-      @selenium_opts[:desired_capabilities] = caps
+    def infer_browser
+      if @options.key?(:browser)
+        @options.delete(:browser)
+      elsif @options.key?(:capabilities)
+        @options[:capabilities].browser_name.tr(' ', '_').downcase.to_sym
+      elsif @options.key?(:options)
+        @options[:options].class.to_s.split('::')[-2].downcase.to_sym
+      else
+        :chrome
+      end
     end
   end
 end

data/lib/watir/cell_container.rb

@@ -6,8 +6,8 @@ module Watir
     # @return [Cell]
     #
 
-    def cell(*args)
-      Cell.new(self, extract_selector(args))
+    def cell(opts = {})
+      Cell.new(self, opts)
     end
 
     #
@@ -16,8 +16,8 @@ module Watir
     # @return [Cell]
     #
 
-    def cells(*args)
-      CellCollection.new(self, extract_selector(args))
+    def cells(opts = {})
+      CellCollection.new(self, opts)
     end
   end # CellContainer
 end # Watir

data/lib/watir/container.rb

@@ -11,8 +11,8 @@ module Watir
     # @return [HTMLElement]
     #
 
-    def element(*args)
-      HTMLElement.new(self, extract_selector(args))
+    def element(opts = {})
+      HTMLElement.new(self, opts)
     end
 
     #
@@ -24,30 +24,8 @@ module Watir
     # @return [HTMLElementCollection]
     #
 
-    def elements(*args)
-      HTMLElementCollection.new(self, extract_selector(args))
-    end
-
-    #
-    # @api private
-    #
-
-    def extract_selector(selector)
-      case selector.size
-      when 2
-        msg = "Using ordered parameters to locate elements (:#{selector.first}, #{selector.last.inspect})"
-        Watir.logger.deprecate msg,
-                               "{#{selector.first}: #{selector.last.inspect}}",
-                               ids: [:selector_parameters]
-        return {selector[0] => selector[1]}
-      when 1
-        obj = selector.first
-        return obj if obj.is_a? Hash
-      when 0
-        return {}
-      end
-
-      raise ArgumentError, "expected Hash, got #{selector.inspect}"
+    def elements(opts = {})
+      HTMLElementCollection.new(self, opts)
     end
   end # Container
 end # Watir

data/lib/watir/cookies.rb

@@ -105,6 +105,8 @@ module Watir
       IO.write(file, to_a.to_yaml)
     end
 
+    #
+    # TODO: Use :permitted_classes keyword when minimum supported Ruby is 2.6
     #
     # Load cookies from file
     #

data/lib/watir/element_collection.rb

@@ -7,17 +7,19 @@ module Watir
     include Enumerable
     include Exception
     include JSSnippets
+    include Waitable
     include Locators::ClassHelpers
 
     def initialize(query_scope, selector)
       @query_scope = query_scope
       @selector = selector
+      @to_a = nil
 
       build unless @selector.key?(:element)
     end
 
     #
-    # Yields each element in collection.
+    # Relocates elements then yields each element in resulting collection.
     #
     # @example
     #   divs = browser.divs(class: 'kls')
@@ -29,6 +31,7 @@ module Watir
     #
 
     def each(&blk)
+      reset!
       to_a.each(&blk)
     end
 
@@ -37,6 +40,9 @@ module Watir
 
     alias empty? none?
 
+    alias exist? any?
+    alias exists? any?
+
     def build
       selector_builder.build(@selector.dup)
     end
@@ -145,14 +151,19 @@ module Watir
     alias eql? ==
 
     #
-    # Creates a Collection containing elements of two collections.
+    # Removes cache of previously located elements in the collection.
     #
     # @example
     #   options = browser.select_list(name: "new_user_languages").options
-    #   (options + browser.select_list(id: "new_user_role").options).size
-    #   #=> 8
+    #   options.reset!
+    #   options[0]
+    #   #=> nil
     #
 
+    def reset!
+      @to_a = nil
+    end
+
     private
 
     def elements
@@ -182,7 +193,11 @@ module Watir
     end
 
     def ensure_context
-      @query_scope.locate if @query_scope.is_a?(Browser) || @query_scope.located? && @query_scope.stale?
+      if @query_scope.is_a?(Browser) || !@query_scope.located? && @query_scope.is_a?(IFrame)
+        @query_scope.browser.locate
+      elsif @query_scope.located? && @query_scope.stale?
+        @query_scope.locate
+      end
       @query_scope.switch_to! if @query_scope.is_a?(IFrame)
     end
 
@@ -191,7 +206,7 @@ module Watir
     end
 
     def element_class
-      Kernel.const_get(self.class.name.sub(/Collection$/, ''))
+      Watir.const_get(self.class.name.sub(/Collection$/, ''))
     end
 
     def construct_subtype(element, hash, tag_name)