watir 6.13.0 → 6.14.0

data/lib/watir/capabilities.rb

@@ -1,6 +1,5 @@
 module Watir
   class Capabilities
-
     attr_reader :options
 
     def initialize(browser, options = {})
@@ -48,10 +47,11 @@ module Watir
 
       http_client = @options.delete(:http_client)
 
-      %i(open_timeout read_timeout client_timeout).each do |t|
+      %i[open_timeout read_timeout client_timeout].each do |t|
         next if http_client.nil? || !respond_to?(t)
-        Watir.logger.warn "You can now pass #{t} value directly into Watir::Browser opt without needing to use :http_client",
-                          ids: [:http_client, :use_capabilities]
+
+        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]
       end
 
       http_client ||= Selenium::WebDriver::Remote::Http::Default.new
@@ -62,6 +62,11 @@ module Watir
       @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) || {}
 
@@ -83,8 +88,8 @@ module Watir
         if browser_options.is_a? Selenium::WebDriver::Firefox::Options
           @selenium_opts[:options] = browser_options
           if profile
-            Watir.logger.deprecate 'Initializing Browser with both :profile and :option', ':profile as a key inside :option',
-                                   ids: [:firefox_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)
@@ -106,16 +111,21 @@ module Watir
           @options[Selenium::WebDriver::Firefox::Options::KEY] = {'args' => args + ['--headless']}
         end
         if @browser == :safari && @options.delete(:technology_preview)
-          @options["safari.options"] = {'technologyPreview' => true}
+          @options['safari.options'] = {'technologyPreview' => true}
         end
       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)
 
       if caps
-        Watir.logger.warn 'You can now pass values directly into Watir::Browser opt without needing to use :desired_capabilities',
+        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
@@ -124,6 +134,5 @@ module Watir
 
       @selenium_opts[:desired_capabilities] = caps
     end
-
   end
-end
+end

data/lib/watir/cell_container.rb

@@ -1,6 +1,5 @@
 module Watir
   module CellContainer
-
     #
     # Returns table cell.
     #
@@ -20,6 +19,5 @@ module Watir
     def cells(*args)
       CellCollection.new(self, extract_selector(args).merge(tag_name: /^(th|td)$/))
     end
-
   end # CellContainer
 end # Watir

data/lib/watir/container.rb

@@ -36,19 +36,19 @@ module Watir
     def extract_selector(selectors)
       case selectors.size
       when 2
-        Watir.logger.deprecate "Using ordered parameters to locate elements (:#{selectors.first}, #{selectors.last.inspect})",
+        msg = "Using ordered parameters to locate elements (:#{selectors.first}, #{selectors.last.inspect})"
+        Watir.logger.deprecate msg,
                                "{#{selectors.first}: #{selectors.last.inspect}}",
                                ids: [:selector_parameters]
-        return { selectors[0] => selectors[1] }
+        return {selectors[0] => selectors[1]}
       when 1
         obj = selectors.first
-        return obj if obj.kind_of? Hash
+        return obj if obj.is_a? Hash
       when 0
         return {}
       end
 
       raise ArgumentError, "expected Hash, got #{selectors.inspect}"
     end
-
   end # Container
 end # Watir

data/lib/watir/cookies.rb

@@ -2,7 +2,6 @@ require 'yaml'
 
 module Watir
   class Cookies
-
     def initialize(control)
       @control = control
     end
@@ -56,7 +55,8 @@ module Watir
     def add(name, value, opts = {})
       cookie = {
         name: name,
-        value: value}
+        value: value
+      }
       cookie[:secure] = opts[:secure] if opts.key?(:secure)
       cookie[:path] = opts[:path] if opts.key?(:path)
       expires = opts[:expires]
@@ -115,20 +115,19 @@ module Watir
     #
 
     def load(file = '.cookies')
-      YAML.load(IO.read(file)).each do |c|
+      YAML.safe_load(IO.read(file), [::Symbol]).each do |c|
         add(c.delete(:name), c.delete(:value), c)
       end
     end
 
     private
 
-    def to_time(t)
-      if t.respond_to?(:to_time)
-        t.to_time
+    def to_time(time)
+      if time.respond_to?(:to_time)
+        time.to_time
       else
-        ::Time.local t.year, t.month, t.day, t.hour, t.min, t.sec
+        ::Time.local time.year, time.month, time.day, time.hour, time.min, time.sec
       end
     end
-
   end # Cookies
 end # Watir

data/lib/watir/element_collection.rb

@@ -1,5 +1,4 @@
 module Watir
-
   #
   # Base class for element collections.
   #
@@ -29,10 +28,10 @@ module Watir
       to_a.each(&blk)
     end
 
-    alias_method :length, :count
-    alias_method :size, :count
+    alias length count
+    alias size count
 
-    alias_method :empty?, :none?
+    alias empty? none?
 
     #
     # Get the element at the given index or range.
@@ -50,7 +49,7 @@ module Watir
       if value.is_a?(Range)
         to_a[value]
       elsif @selector.key? :adjacent
-        to_a[value] || element_class.new(@query_scope, {invalid_locator: true})
+        to_a[value] || element_class.new(@query_scope, invalid_locator: true)
       elsif @to_a && @to_a[value]
         @to_a[value]
       else
@@ -87,19 +86,21 @@ module Watir
     def to_a
       hash = {}
       @to_a ||=
-          elements.map.with_index do |e, idx|
-            element = element_class.new(@query_scope, @selector.merge(element: e, index: idx))
-            if [Watir::HTMLElement, Watir::Input].include? element.class
-              tag_name = @selector[:tag_name] || element.tag_name.to_sym
-              hash[tag_name] ||= 0
-              hash[tag_name] += 1
-              Watir.element_class_for(tag_name).new(@query_scope, @selector.merge(element: e,
-                                                                                   tag_name: tag_name,
-                                                                                   index: hash[tag_name] - 1))
-            else
-              element
-            end
+        elements.map.with_index do |e, idx|
+          selector = @selector.merge(element: e)
+          selector[:index] = idx
+          element = element_class.new(@query_scope, selector)
+          if [Watir::HTMLElement, Watir::Input].include? element.class
+            tag_name = @selector[:tag_name] || element.tag_name.to_sym
+            hash[tag_name] ||= 0
+            hash[tag_name] += 1
+            selector[:index] = hash[tag_name] - 1
+            selector[:tag_name] = tag_name
+            Watir.element_class_for(tag_name).new(@query_scope, selector)
+          else
+            element
           end
+        end
     end
 
     #
@@ -138,26 +139,40 @@ module Watir
     def ==(other)
       to_a == other.to_a
     end
-    alias_method :eql?, :==
+    alias eql? ==
 
     #
     # Creates a Collection containing elements of two collections.
     #
     # @example
-    #   (browser.select_list(name: "new_user_languages").options + browser.select_list(id: "new_user_role").options).size
+    #   options = browser.select_list(name: "new_user_languages").options
+    #   (options + browser.select_list(id: "new_user_role").options).size
     #   #=> 8
     #
 
     private
 
     def elements
-      @locator ||= build_locator
-      @elements ||= @locator.locate_all
+      ensure_context
+      if @query_scope.is_a?(Browser)
+        locate_all
+      else
+        # This gives all of the standard Watir waiting behaviors to Collections
+        @query_scope.send(:element_call) { locate_all }
+      end
+    end
+
+    def ensure_context
+      @query_scope.locate if @query_scope.relocate?
+      @query_scope.switch_to! if @query_scope.is_a?(IFrame)
+    end
+
+    def locate_all
+      build_locator.locate_all
     end
 
     def element_class
       Kernel.const_get(self.class.name.sub(/Collection$/, ''))
     end
-
   end # ElementCollection
 end # Watir

data/lib/watir/elements/area.rb

@@ -1,12 +1,10 @@
 module Watir
   class Area < HTMLElement
-
     #
     # @todo temporarily add href attribute
     #
     # @see https://www.w3.org/Bugs/Public/show_bug.cgi?id=23192
     #
     attribute String, :href, :href
-
   end # Area
 end # Watir

data/lib/watir/elements/button.rb

@@ -1,5 +1,4 @@
 module Watir
-
   #
   # Class representing button elements.
   #
@@ -7,10 +6,9 @@ module Watir
   #
 
   class Button < HTMLElement
-
     inherit_attributes_from Watir::Input
 
-    VALID_TYPES = %w[button reset submit image]
+    VALID_TYPES = %w[button reset submit image].freeze
 
     #
     # Returns the text of the button.

data/lib/watir/elements/cell.rb

@@ -1,5 +1,4 @@
 module Watir
-
   #
   # Custom class representing table cell (th or td).
   #

data/lib/watir/elements/checkbox.rb

@@ -1,6 +1,5 @@
 module Watir
   class CheckBox < Input
-
     #
     # Sets checkbox to the given value.
     #
@@ -18,7 +17,7 @@ module Watir
     def set(bool = true)
       set? == bool ? assert_enabled : click
     end
-    alias_method :check, :set
+    alias check set
 
     #
     # Returns true if the element is checked
@@ -28,7 +27,7 @@ module Watir
     def set?
       element_call { @element.selected? }
     end
-    alias_method :checked?, :set?
+    alias checked? set?
 
     #
     # Unsets checkbox.
@@ -37,17 +36,16 @@ module Watir
     def clear
       set false
     end
-    alias_method :uncheck, :clear
-
+    alias uncheck clear
   end # CheckBox
 
   module Container
     def checkbox(*args)
-      CheckBox.new(self, extract_selector(args).merge(tag_name: "input", type: "checkbox"))
+      CheckBox.new(self, extract_selector(args).merge(tag_name: 'input', type: 'checkbox'))
     end
 
     def checkboxes(*args)
-      CheckBoxCollection.new(self, extract_selector(args).merge(tag_name: "input", type: "checkbox"))
+      CheckBoxCollection.new(self, extract_selector(args).merge(tag_name: 'input', type: 'checkbox'))
     end
   end # Container
 

data/lib/watir/elements/date_field.rb

@@ -1,6 +1,5 @@
 module Watir
   class DateField < Input
-
     #
     # Enter the provided value.
     #
@@ -11,23 +10,20 @@ module Watir
       message = "DateField##{__callee__} only accepts instances of Date or Time"
       raise ArgumentError, message unless [Date, ::Time].include?(date.class)
 
-      date_string = date.strftime("%Y-%m-%d")
+      date_string = date.strftime('%Y-%m-%d')
       element_call(:wait_for_writable) { execute_js(:setValue, @element, date_string) }
     end
-    alias_method :set, :set!
-    alias_method :value=, :set
-
-    protected
-
+    alias set set!
+    alias value= set
   end # DateField
 
   module Container
     def date_field(*args)
-      DateField.new(self, extract_selector(args).merge(tag_name: "input", type: "date"))
+      DateField.new(self, extract_selector(args).merge(tag_name: 'input', type: 'date'))
     end
 
     def date_fields(*args)
-      DateFieldCollection.new(self, extract_selector(args).merge(tag_name: "input", type: "date"))
+      DateFieldCollection.new(self, extract_selector(args).merge(tag_name: 'input', type: 'date'))
     end
   end # Container
 

data/lib/watir/elements/date_time_field.rb

@@ -1,33 +1,29 @@
 module Watir
   class DateTimeField < Input
-
     #
     # Enter the provided value.
     #
 
     def set!(date)
-      date = DateTime.parse date if date.is_a?(String)
+      date = ::Time.parse date if date.is_a?(String)
 
       message = "DateTimeField##{__callee__} only accepts instances of DateTime or Time"
       raise ArgumentError, message unless [DateTime, ::Time].include?(date.class)
 
-      date_time_string = date.strftime("%Y-%m-%dT%H:%M")
+      date_time_string = date.strftime('%Y-%m-%dT%H:%M')
       element_call(:wait_for_writable) { execute_js(:setValue, @element, date_time_string) }
     end
-    alias_method :set, :set!
-    alias_method :value=, :set
-
-    protected
-
+    alias set set!
+    alias value= set
   end # DateTimeField
 
   module Container
     def date_time_field(*args)
-      DateTimeField.new(self, extract_selector(args).merge(tag_name: "input", type: "datetime-local"))
+      DateTimeField.new(self, extract_selector(args).merge(tag_name: 'input', type: 'datetime-local'))
     end
 
     def date_time_fields(*args)
-      DateTimeFieldCollection.new(self, extract_selector(args).merge(tag_name: "input", type: "datetime-local"))
+      DateTimeFieldCollection.new(self, extract_selector(args).merge(tag_name: 'input', type: 'datetime-local'))
     end
   end # Container
 

data/lib/watir/elements/dlist.rb

@@ -1,12 +1,10 @@
 module Watir
   class DList < HTMLElement
-
     def to_hash
-      keys = dts.map { |e| e.text }
-      values = dds.map { |e| e.text }
+      keys = dts.map(&:text)
+      values = dds.map(&:text)
 
       Hash[keys.zip(values)]
     end
-
   end # DList
 end # Watir

data/lib/watir/elements/element.rb

@@ -1,5 +1,4 @@
 module Watir
-
   #
   # Base class for HTML elements.
   #
@@ -32,9 +31,7 @@ module Watir
     def initialize(query_scope, selector)
       @query_scope = query_scope
 
-      unless selector.kind_of? Hash
-        raise ArgumentError, "invalid argument: #{selector.inspect}"
-      end
+      raise ArgumentError, "invalid argument: #{selector.inspect}" unless selector.is_a? Hash
 
       @element = selector.delete(:element)
       @selector = selector
@@ -42,28 +39,30 @@ module Watir
 
     #
     # Returns true if element exists.
+    # Checking for staleness is deprecated
     #
     # @return [Boolean]
     #
 
     def exists?
-      return false if @element && stale?
+      return false if located? && stale?
+
       assert_exists
       true
     rescue UnknownObjectException, UnknownFrameException
       false
     end
-    alias_method :exist?, :exists?
+    alias exist? exists?
 
     def inspect
       string = "#<#{self.class}: "
       string << "keyword: #{keyword} " if keyword
-      string << "located: #{!!@element}; "
-      if @selector.empty?
-        string << '{element: (selenium element)}'
-      else
-        string << selector_string
-      end
+      string << "located: #{located?}; "
+      string << if @selector.empty?
+                  '{element: (selenium element)}'
+                else
+                  selector_string
+                end
       string << '>'
       string
     end
@@ -71,6 +70,10 @@ module Watir
     #
     # Returns true if two elements are equal.
     #
+    # TODO: Address how this is affected by stale elements
+    # TODO: Address how this is affected by HTMLElement vs subclass
+    # TODO: Address how this is affected by a non-located element
+    #
     # @example
     #   browser.text_field(name: "new_user_first_name") == browser.text_field(name: "new_user_first_name")
     #   #=> true
@@ -79,10 +82,10 @@ module Watir
     def ==(other)
       other.is_a?(self.class) && wd == other.wd
     end
-    alias_method :eql?, :==
+    alias eql? ==
 
     def hash
-      @element ? @element.hash : super
+      located? ? @element.hash : super
     end
 
     #
@@ -176,7 +179,6 @@ module Watir
       browser.after_hooks.run
     end
 
-
     #
     # Right clicks the element.
     # Note that browser support may vary.
@@ -216,9 +218,9 @@ module Watir
       assert_is_element other
 
       value = element_call(:wait_for_present) do
-        driver.action.
-               drag_and_drop(@element, other.wd).
-               perform
+        driver.action
+              .drag_and_drop(@element, other.wd)
+              .perform
       end
       browser.after_hooks.run
       value
@@ -237,9 +239,9 @@ module Watir
 
     def drag_and_drop_by(right_by, down_by)
       element_call(:wait_for_present) do
-        driver.action.
-               drag_and_drop_by(@element, right_by, down_by).
-               perform
+        driver.action
+              .drag_and_drop_by(@element, right_by, down_by)
+              .perform
       end
     end
 
@@ -270,7 +272,44 @@ module Watir
       attribute_name = attribute_name.to_s.tr('_', '-') if attribute_name.is_a?(::Symbol)
       element_call { @element.attribute attribute_name }
     end
-    alias_method :attribute, :attribute_value
+    alias attribute attribute_value
+
+    #
+    # Returns all attribute values. Attributes with special characters are returned as String,
+    # rest are returned as a Symbol.
+    #
+    # @return [Hash]
+    #
+    # @example
+    #   browser.pre(id: 'rspec').attribute_values
+    #   #=> {class:'ruby', id: 'rspec' }
+    #
+
+    def attribute_values
+      result = element_call { execute_js(:attributeValues, @element) }
+      result.keys.each do |key|
+        next unless key == key[/[a-zA-Z\-]*/]
+
+        result[key.tr('-', '_').to_sym] = result.delete(key)
+      end
+      result
+    end
+    alias attributes attribute_values
+
+    #
+    # Returns list of all attributes. Attributes with special characters are returned as String,
+    # rest are returned as a Symbol.
+    #
+    # @return [Array]
+    #
+    # @example
+    #   browser.pre(id: 'rspec').attribute_list
+    #   #=> [:class, :id]
+    #
+
+    def attribute_list
+      attribute_values.keys
+    end
 
     #
     # Sends sequence of keystrokes to element.
@@ -372,10 +411,10 @@ module Watir
     def center
       point = location
       dimensions = size
-      Selenium::WebDriver::Point.new(point.x + (dimensions['width']/2),
-                                     point.y + (dimensions['height']/2))
+      Selenium::WebDriver::Point.new(point.x + (dimensions['width'] / 2),
+                                     point.y + (dimensions['height'] / 2))
     end
-    alias_method :centre, :center
+    alias centre center
 
     #
     # @api private
@@ -386,12 +425,13 @@ module Watir
     end
 
     #
-    # @api private
+    # Returns underlying Selenium object of the Watir Element
+    #
+    # @return [Selenium::WebDriver::Element]
     #
 
     def wd
-      assert_exists if @element.nil?
-      return driver if @element.is_a? FramedDriver
+      assert_exists
       @element
     end
 
@@ -403,15 +443,19 @@ module Watir
     #
 
     def visible?
-      Watir.logger.warn "#visible? behavior will be changing slightly, consider switching to #present? (more details: http://watir.com/element-existentialism/)",
-                             ids: [:visible_element]
-      assert_exists
-      @element.displayed?
-    rescue Selenium::WebDriver::Error::StaleElementReferenceError
-      Watir.logger.deprecate "Checking `#visible? == false` to determine a stale element", "`#stale? == true`",
-                             ids: [:stale_visible]
-      reset!
-      raise unknown_exception
+      msg = '#visible? behavior will be changing slightly, consider switching to #present? ' \
+            '(more details: http://watir.com/element-existentialism/)'
+      Watir.logger.warn msg, ids: [:visible_element]
+      displayed = display_check
+      if displayed.nil? && display_check
+        Watir.logger.deprecate 'Checking `#present? == false` to determine a stale element',
+                               '`#stale? == true`',
+                               reference: 'http://watir.com/staleness-changes',
+                               ids: [:stale_visible]
+      end
+      raise unknown_exception if displayed.nil?
+
+      displayed
     end
 
     #
@@ -434,13 +478,14 @@ module Watir
     #
 
     def present?
-      assert_exists
-      @element.displayed?
-    rescue Selenium::WebDriver::Error::StaleElementReferenceError
-      Watir.logger.deprecate "Checking `#present? == false` to determine a stale element", "`#stale? == true`",
-                             ids: [:stale_present]
-      reset!
-      false
+      displayed = display_check
+      if displayed.nil? && display_check
+        Watir.logger.deprecate 'Checking `#present? == false` to determine a stale element',
+                               '`#stale? == true`',
+                               reference: 'http://watir.com/staleness-changes',
+                               ids: [:stale_present]
+      end
+      displayed
     rescue UnknownObjectException, UnknownFrameException
       false
     end
@@ -460,7 +505,7 @@ module Watir
       if property
         element_call { @element.style property }
       else
-        attribute_value("style").to_s.strip
+        attribute_value('style').to_s.strip
       end
     end
 
@@ -474,16 +519,16 @@ module Watir
 
     def to_subtype
       tag = tag_name()
-      klass = if tag == "input"
+      klass = if tag == 'input'
                 case attribute_value(:type)
-                when *Button::VALID_TYPES
-                  Button
                 when 'checkbox'
                   CheckBox
                 when 'radio'
                   Radio
                 when 'file'
                   FileField
+                when *Button::VALID_TYPES
+                  Button
                 else
                   TextField
                 end
@@ -512,22 +557,67 @@ module Watir
     #
 
     def stale?
-      raise Watir::Exception::Error, "Can not check staleness of unused element" unless @element
-      @query_scope.ensure_context
-      @stale || stale_in_context?
+      raise Watir::Exception::Error, 'Can not check staleness of unused element' unless @element
+
+      ensure_context
+      stale_in_context?
     end
 
     def stale_in_context?
       @element.enabled? # any wire call will check for staleness
       false
     rescue Selenium::WebDriver::Error::ObsoleteElementError
-      @stale = true
+      true
     end
 
     def reset!
       @element = nil
     end
 
+    #
+    # @api private
+    #
+
+    def locate
+      ensure_context
+      locate_in_context
+    end
+
+    #
+    # @api private
+    #
+    # Returns true if element has been previously located.
+    #
+    # @return [Boolean]
+    #
+
+    def located?
+      !!@element
+    end
+
+    #
+    # @api private
+    #
+    # This is a performance shortcut for ensuring context
+    # Returns true if ensuring context requires relocating the element.
+    #
+    # @return [Boolean]
+    #
+
+    def relocate?
+      located? && stale?
+    end
+
+    #
+    # @api private
+    #
+
+    def selector_string
+      return @selector.inspect if @query_scope.is_a?(Browser)
+
+      "#{@query_scope.selector_string} --> #{@selector.inspect}"
+    end
+
     protected
 
     def wait_for_exists
@@ -551,7 +641,8 @@ module Watir
         @query_scope.wait_for_present unless @query_scope.is_a? Browser
         wait_until_present
       rescue Watir::Wait::TimeoutError
-        msg = "element located, but timed out after #{Watir.default_timeout} seconds, waiting for #{inspect} to be present"
+        msg = "element located, but timed out after #{Watir.default_timeout} seconds, " \
+              "waiting for #{inspect} to be present"
         raise unknown_exception, msg
       end
     end
@@ -560,7 +651,7 @@ module Watir
       return assert_enabled unless Watir.relaxed_locate?
 
       wait_for_exists
-      return if [Input, Button, Select, Option].none? { |c| self.is_a? c }
+      return if [Input, Button, Select, Option].none? { |c| is_a? c }
 
       begin
         wait_until(&:enabled?)
@@ -570,7 +661,6 @@ module Watir
     end
 
     def wait_for_writable
-      wait_for_exists
       wait_for_enabled
       unless Watir.relaxed_locate?
         raise_writable unless !respond_to?(:readonly?) || !readonly?
@@ -579,31 +669,28 @@ module Watir
       begin
         wait_until { !respond_to?(:readonly?) || !readonly? }
       rescue Watir::Wait::TimeoutError
-        message = "element present and enabled, but timed out after #{Watir.default_timeout} seconds, waiting for #{inspect} to not be readonly"
+        message = "element present and enabled, but timed out after #{Watir.default_timeout} seconds, " \
+                  "waiting for #{inspect} to not be readonly"
         raise ObjectReadOnlyException, message
       end
     end
 
-    # Ensure that the element exists, making sure that it is not stale and located if necessary
+    # Locates if not previously found; does not check for staleness for performance reasons
     def assert_exists
-      locate unless @element
-      return if @element
-      raise unknown_exception, "unable to locate element: #{inspect}"
-    end
+      locate unless located?
+      return if located?
 
-    def locate
-      @locator = build_locator
-      @element = @locator.locate
+      raise unknown_exception, "unable to locate element: #{inspect}"
     end
 
-    def selector_string
-      return @selector.inspect if @query_scope.is_a?(Browser)
-      "#{@query_scope.send :selector_string} --> #{@selector.inspect}"
+    def ensure_context
+      @query_scope.locate if @query_scope.relocate?
+      @query_scope.switch_to! if @query_scope.is_a?(IFrame)
     end
 
-    # Ensure the driver is in the desired browser context
-    def ensure_context
-      locate unless exists?
+    def locate_in_context
+      @locator = build_locator
+      @element = @locator.locate
     end
 
     private
@@ -613,17 +700,21 @@ module Watir
     end
 
     def raise_writable
-      message = "element present and enabled, but timed out after #{Watir.default_timeout} seconds, waiting for #{inspect} to not be readonly"
+      message = "element present and enabled, but timed out after #{Watir.default_timeout} seconds, " \
+                "waiting for #{inspect} to not be readonly"
       raise ObjectReadOnlyException, message
     end
 
     def raise_disabled
-      message = "element present, but timed out after #{Watir.default_timeout} seconds, waiting for #{inspect} to be enabled"
+      message = "element present, but timed out after #{Watir.default_timeout} seconds, " \
+                "waiting for #{inspect} to be enabled"
       raise ObjectDisabledException, message
     end
 
     def raise_present
-      raise unknown_exception, "element located, but timed out after #{Watir.default_timeout} seconds, waiting for #{inspect} to be present"
+      message = "element located, but timed out after #{Watir.default_timeout} seconds, " \
+                               "waiting for #{inspect} to be present"
+      raise unknown_exception, message
     end
 
     def element_class
@@ -635,76 +726,88 @@ module Watir
     end
 
     def assert_enabled
-      unless element_call { @element.enabled? }
-        raise ObjectDisabledException, "object is disabled #{inspect}"
-      end
+      raise ObjectDisabledException, "object is disabled #{inspect}" unless element_call { @element.enabled? }
     end
 
     def assert_is_element(obj)
-      unless obj.kind_of? Watir::Element
-        raise TypeError, "execpted Watir::Element, got #{obj.inspect}:#{obj.class}"
-      end
+      raise TypeError, "execpted Watir::Element, got #{obj.inspect}:#{obj.class}" unless obj.is_a? Watir::Element
     end
 
+    # Removes duplication in #present? & #visible? and makes setting deprecation notice easier
+    def display_check
+      assert_exists
+      @element.displayed?
+    rescue Selenium::WebDriver::Error::StaleElementReferenceError
+      reset!
+      nil
+    end
+
+    # TODO: - this will get addressed with Watir::Executor implementation
+    # rubocop:disable Metrics/AbcSize
+    # rubocop:disable Metrics/MethodLength
+    # rubocop:disable Metrics/PerceivedComplexity
+    # rubocop:disable Metrics/CyclomaticComplexity:
     def element_call(precondition = nil, &block)
       caller = caller_locations(1, 1)[0].label
       already_locked = Wait.timer.locked?
-      unless already_locked
-        Wait.timer = Wait::Timer.new(timeout: Watir.default_timeout)
-      end
+      Wait.timer = Wait::Timer.new(timeout: Watir.default_timeout) unless already_locked
 
       begin
-        check_condition(precondition)
+        check_condition(precondition, caller)
         Watir.logger.info "-> `Executing #{inspect}##{caller}`"
         yield
       rescue unknown_exception => ex
-        if precondition.nil?
-          element_call(:wait_for_exists, &block)
-        end
+        element_call(:wait_for_exists, &block) if precondition.nil?
         msg = ex.message
-        msg += "; Maybe look in an iframe?" if @query_scope.ensure_context && @query_scope.iframes.count > 0
+        msg += '; Maybe look in an iframe?' if @query_scope.iframe.exists?
         custom_attributes = @locator.nil? ? [] : @locator.selector_builder.custom_attributes
-        msg += "; Watir treated #{custom_attributes} as a non-HTML compliant attribute, ensure that was intended" unless custom_attributes.empty?
+        unless custom_attributes.empty?
+          msg += "; Watir treated #{custom_attributes} as a non-HTML compliant attribute, ensure that was intended"
+        end
         raise unknown_exception, msg
       rescue Selenium::WebDriver::Error::StaleElementReferenceError
-        @query_scope.ensure_context
         reset!
         retry
       rescue Selenium::WebDriver::Error::ElementNotVisibleError, Selenium::WebDriver::Error::ElementNotInteractableError
-        raise_present unless Wait.timer.remaining_time > 0
+        raise_present unless Wait.timer.remaining_time.positive?
         raise_present unless %i[wait_for_present wait_for_enabled wait_for_writable].include?(precondition)
         retry
       rescue Selenium::WebDriver::Error::InvalidElementStateError
-        raise_disabled unless Wait.timer.remaining_time > 0
+        raise_disabled unless Wait.timer.remaining_time.positive?
         raise_disabled unless %i[wait_for_present wait_for_enabled wait_for_writable].include?(precondition)
         retry
       rescue Selenium::WebDriver::Error::NoSuchWindowError
-        raise Exception::NoMatchingWindowFoundException, "browser window was closed"
+        raise Exception::NoMatchingWindowFoundException, 'browser window was closed'
       ensure
         Watir.logger.info "<- `Completed #{inspect}##{caller}`"
         Wait.timer.reset! unless already_locked
       end
     end
+    # rubocop:enable Metrics/AbcSize
+    # rubocop:enable Metrics/MethodLength
+    # rubocop:enable Metrics/PerceivedComplexity
+    # rubocop:enable Metrics/CyclomaticComplexity:
 
-    def check_condition(condition)
-      Watir.logger.info "<- `Verifying precondition #{inspect}##{condition}`"
+    def check_condition(condition, caller)
+      Watir.logger.info "<- `Verifying precondition #{inspect}##{condition} for #{caller}`"
       begin
         condition.nil? ? assert_exists : send(condition)
         Watir.logger.info "<- `Verified precondition #{inspect}##{condition || 'assert_exists'}`"
       rescue unknown_exception
         raise unless condition.nil?
+
         Watir.logger.info "<- `Unable to satisfy precondition #{inspect}##{condition}`"
-        check_condition(:wait_for_exists)
+        check_condition(:wait_for_exists, caller)
       end
     end
 
     def method_missing(meth, *args, &blk)
       method = meth.to_s
       if method =~ Locators::Element::SelectorBuilder::WILDCARD_ATTRIBUTE
-        attribute_value(method.tr('_', '-'), *args)
+        attribute_value(meth, *args)
       elsif UserEditable.instance_methods(false).include?(meth) && content_editable?
         @content_editable = true
-        self.extend UserEditable
+        extend UserEditable
         send(meth, *args, &blk)
       else
         super
@@ -712,8 +815,7 @@ module Watir
     end
 
     def respond_to_missing?(meth, *)
-      Locators::Element::SelectorBuilder::WILDCARD_ATTRIBUTE === meth.to_s || super
+      meth.to_s =~ Locators::Element::SelectorBuilder::WILDCARD_ATTRIBUTE || super
     end
-
   end # Element
 end # Watir