watir 6.11.0 → 6.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA256:
-  metadata.gz: 8eaa5c46491ba52da6c95709e75cc9759e51de70b8a5687c2d44668c1bcd7bee
-  data.tar.gz: e66fd1830e0442e4165476ecdca900ec5aaf0aa7879f8006c223402d9442ad0d
+SHA1:
+  metadata.gz: ea86da9b066569e766ab50f2f0657d7bc77501ab
+  data.tar.gz: 07ad7bd26a6dc2b01b998fe64ef5254289541dc1
 SHA512:
-  metadata.gz: 3492caa375debcda81ccc04efec7d2c34af1caa9689ad66e6d60d44bc23f51c103a60070e493d0d1e54255fc77837f10e5aa54054dd66ae1c794546f6ec29ceb
-  data.tar.gz: d27c43b7e043a1f2602959bc48be08efe4d4a12fa6ce5f353c1ea38f4b629452153c5232a393510dbed4608fd18fd8f69fbf7a08c573036ee3017d163d781e82
+  metadata.gz: 4814e526875cba217e35219544f3322baecd947df1e00cb347224bf544cdc806bcd51768ca6394130f792b575010240dbcaba141468760aab448cfcd9e14228e
+  data.tar.gz: a6fc636ad8301a955430501f5d293094b4028337a80ef9b2c7a6dfdc634f4482dab0c7c84216651f8a8037b5c0f310be06467e359a43707a0477eb6e64bf1c89

data/CHANGES.md

@@ -1,3 +1,20 @@
+### 6.12.0 (2018-07-24)
+
+* Allow elements to be located with attributes that have underscores (thanks John Fitisoff)
+* Get array of elements from an Element Collection using a Range (#738)
+* Deprecate using `#present?` or `#visible?` to determine if an element is stale
+* Allow getting element attribute values with a Symbol
+* Add new functionality to `#flash` (thanks Gijs Paulides)
+* Fix bug preventing text_field from waiting until present (#675)
+* Fix bug allowing `StaleElementReferenceError` during element location
+* Add support for Wait methods to receive `Proc` as message values
+* Add support to ignore specific warnings logged by Watir
+* Deprecate locating elements by ordered parameters
+* Changed scope for locator namespacing (Thanks Aleksandar)
+* Deprecate current implementation of `#visible?`
+* Update logic `#wait_while_present` and `#wait_until_present`
+* Deprecate `#wait_while_present` and `#wait_until_present` for non-Element classes
+
 ### 6.11.0 (2018-05-18)
 
 * Improve lazy loading of element collections

data/lib/watir.rb

@@ -24,7 +24,7 @@ module Watir
 
   class << self
 
-    attr_writer :relaxed_locate, :always_locate, :default_timeout, :prefer_css, :locator_namespace
+    attr_writer :relaxed_locate, :always_locate, :default_timeout, :prefer_css
 
     #
     # Whether or not Watir should wait for an element to be found or present
@@ -46,11 +46,12 @@ module Watir
     end
 
     def always_locate_message
-      Watir.logger.warn <<-EOS
+      msg = <<-EOS.gsub("\n", " ")
 Watir#always_locate is deprecated; elements are always cached and will always
 be re-located if they go stale before use.
 Use Element#stale? or Element#wait_until(&:stale?) if needed for flow control.
       EOS
+      Watir.logger.warn msg, ids: [:always_locate, :deprecations]
     end
 
     #
@@ -63,11 +64,12 @@ Use Element#stale? or Element#wait_until(&:stale?) if needed for flow control.
     end
 
     def prefer_css_message
-      Watir.logger.warn <<-EOS
+      msg = <<-EOS.gsub("\n", " ")
 Watir#prefer_css is deprecated; all elements that can not be passed directly
 as Selenium locators will be translated to XPath. To continue using CSS Selectors
 require the watir_css gem - https://github.com/watir/watir_css
       EOS
+      Watir.logger.warn msg, ids: [:prefer_css, :deprecations]
     end
 
     #
@@ -78,15 +80,6 @@ require the watir_css gem - https://github.com/watir/watir_css
       @default_timeout ||= 30
     end
 
-    #
-    # Whether the locators should be used from a different namespace.
-    # Defaults to Watir::Locators.
-    #
-
-    def locator_namespace
-      @locator_namespace ||= Watir::Locators
-    end
-
     #
     # @api private
     #
@@ -156,5 +149,3 @@ require 'watir/elements/input'
 require 'watir/radio_set'
 
 require 'watir/aliases'
-
-Watir.tag_to_class.freeze

data/lib/watir/adjacent.rb

@@ -58,7 +58,7 @@ module Watir
     #
     # @example
     #   browser.text_field(name: "new_user_first_name").following_siblings.size
-    #   #=> 52
+    #   #=> 53
     #
 
     def following_siblings(opt = {})
@@ -73,7 +73,7 @@ module Watir
     #
     # @example
     #   browser.text_field(name: "new_user_first_name").siblings.size
-    #   #=> 56
+    #   #=> 57
     #
 
     def siblings(opt = {})

data/lib/watir/alert.rb

@@ -110,7 +110,7 @@ module Watir
           message = "This code has slept for the duration of the default timeout "
           message << "waiting for an Alert to exist. If the test is still passing, "
           message << "consider using Alert#exists? instead of rescuing UnknownObjectException"
-          Watir.logger.warn message
+          Watir.logger.warn message, ids: [:wait_for_alert]
         end
         raise Exception::UnknownObjectException, 'unable to locate alert'
       end

data/lib/watir/browser.rb

@@ -9,7 +9,7 @@ module Watir
     include HasWindow
     include Waitable
 
-    attr_writer :default_context, :original_window
+    attr_writer :default_context, :original_window, :locator_namespace
     attr_reader :driver
     attr_reader :after_hooks
     alias_method :wd, :driver # ensures duck typing with Watir::Element
@@ -290,7 +290,7 @@ module Watir
     #
 
     def screenshot
-      Screenshot.new driver
+      Screenshot.new self
     end
 
     #
@@ -326,6 +326,15 @@ module Watir
       self
     end
 
+    #
+    # Whether the locators should be used from a different namespace.
+    # Defaults to Watir::Locators.
+    #
+
+    def locator_namespace
+      @locator_namespace ||= Watir::Locators
+    end
+
     private
 
     def wrap_elements_in(scope, obj)

data/lib/watir/capabilities.rb

@@ -50,7 +50,8 @@ module Watir
 
       %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"
+        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]
       end
 
       http_client ||= Selenium::WebDriver::Remote::Http::Default.new
@@ -81,7 +82,10 @@ module Watir
         profile = @options.delete(:profile)
         if browser_options.is_a? Selenium::WebDriver::Firefox::Options
           @selenium_opts[:options] = browser_options
-          Watir.logger.deprecate 'Initializing Browser with both :profile and :option', ':profile as a key inside :option' if profile
+          if profile
+            Watir.logger.deprecate 'Initializing Browser with both :profile and :option', ':profile as a key inside :option',
+                                   ids: [:firefox_profile]
+          end
         end
         if @options.delete(:headless)
           browser_options ||= {}
@@ -111,7 +115,8 @@ module Watir
       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'
+        Watir.logger.warn 'You can now pass values directly into Watir::Browser opt without needing to use :desired_capabilities',
+                          ids: [:use_capabilities]
         @selenium_opts.merge!(@options)
       else
         caps = Selenium::WebDriver::Remote::Capabilities.send @browser, @options

data/lib/watir/container.rb

@@ -36,6 +36,9 @@ 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})",
+                               "{#{selectors.first}: #{selectors.last.inspect}}",
+                               ids: [:selector_parameters]
         return { selectors[0] => selectors[1] }
       when 1
         obj = selectors.first
@@ -44,7 +47,7 @@ module Watir
         return {}
       end
 
-      raise ArgumentError, "expected Hash or (:how, 'what'), got #{selectors.inspect}"
+      raise ArgumentError, "expected Hash, got #{selectors.inspect}"
     end
 
   end # Container

data/lib/watir/element_collection.rb

@@ -35,20 +35,24 @@ module Watir
     alias_method :empty?, :none?
 
     #
-    # Get the element at the given index.
+    # Get the element at the given index or range.
     #
     # Any call to an ElementCollection including an adjacent selector
     # can not be lazy loaded because it must store correct type
     #
-    # @param [Integer] idx Index of wanted element, 0-indexed
-    # @return [Watir::Element] Returns an instance of a Watir::Element subclass
+    # Ranges can not be lazy loaded
+    #
+    # @param [Integer, Range] value Index (0-based) or Range of desired element(s)
+    # @return [Watir::Element, Watir::ElementCollection] Returns an instance of a Watir::Element subclass
     #
 
-    def [](idx)
-      if @selector.key? :adjacent
-        to_a[idx] || element_class.new(@query_scope, {invalid_locator: true})
+    def [](value)
+      if value.is_a?(Range)
+        to_a[value]
+      elsif @selector.key? :adjacent
+        to_a[value] || element_class.new(@query_scope, {invalid_locator: true})
       else
-        element_class.new(@query_scope, @selector.merge(index: idx))
+        element_class.new(@query_scope, @selector.merge(index: value))
       end
     end
 
@@ -87,9 +91,9 @@ module Watir
               tag_name = element.tag_name.to_sym
               hash[tag_name] ||= 0
               hash[tag_name] += 1
-              Watir.tag_to_class[tag_name].new(@query_scope, @selector.merge(element: e,
-                                                                             tag_name: tag_name,
-                                                                             index: 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
@@ -107,6 +111,16 @@ module Watir
       self
     end
 
+    #
+    # Returns browser.
+    #
+    # @return [Watir::Browser]
+    #
+
+    def browser
+      @query_scope.browser
+    end
+
     #
     # Returns true if two element collections are equal.
     #

data/lib/watir/elements/element.rb

@@ -262,11 +262,12 @@ module Watir
     #   browser.a(id: "link_2").attribute_value "title"
     #   #=> "link_title_2"
     #
-    # @param [String] attribute_name
+    # @param [String, ::Symbol] attribute_name
     # @return [String, nil]
     #
 
     def attribute_value(attribute_name)
+      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
@@ -402,9 +403,13 @@ 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
     end
@@ -429,7 +434,13 @@ module Watir
     #
 
     def present?
-      visible?
+      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
     rescue UnknownObjectException, UnknownFrameException
       false
     end
@@ -534,8 +545,8 @@ module Watir
     end
 
     def wait_for_present
-      return visible? unless Watir.relaxed_locate?
-      return if present?
+      p = present?
+      return p if !Watir.relaxed_locate? || p
 
       begin
         @query_scope.wait_for_present unless @query_scope.is_a? Browser
@@ -555,8 +566,7 @@ module Watir
       begin
         wait_until(&:enabled?)
       rescue Watir::Wait::TimeoutError
-        message = "element present, but timed out after #{Watir.default_timeout} seconds, waiting for #{inspect} to be enabled"
-        raise ObjectDisabledException, message
+        raise_disabled
       end
     end
 
@@ -609,7 +619,7 @@ module Watir
     end
 
     def raise_disabled
-      message = "element present and enabled, but timed out after #{Watir.default_timeout} seconds, waiting for #{inspect} to not be disabled"
+      message = "element present, but timed out after #{Watir.default_timeout} seconds, waiting for #{inspect} to be enabled"
       raise ObjectDisabledException, message
     end
 
@@ -663,11 +673,11 @@ module Watir
         retry
       rescue Selenium::WebDriver::Error::ElementNotVisibleError, Selenium::WebDriver::Error::ElementNotInteractableError
         raise_present unless Wait.timer.remaining_time > 0
-        raise_present unless precondition == :wait_for_present || precondition == :wait_for_enabled
+        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 precondition == :wait_for_writable || precondition == :wait_for_enabled
+        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"

data/lib/watir/elements/select.rb

@@ -94,7 +94,7 @@ module Watir
     #
 
     def select_value(str_or_rx)
-      Watir.logger.deprecate '#select_value', "#select"
+      Watir.logger.deprecate '#select_value', "#select", ids: [:select_value]
       select_by str_or_rx
     end
 
@@ -157,7 +157,8 @@ module Watir
       found = find_options(:value, str_or_rx)
 
       if found && found.size > 1
-        Watir.logger.deprecate "Selecting Multiple Options with #select", "#select_all"
+        Watir.logger.deprecate "Selecting Multiple Options with #select", "#select_all",
+                               ids: [:select_by]
       end
       return select_matching(found) if found && found.any?
       raise NoValueFoundException, "#{str_or_rx.inspect} not found in select list"

data/lib/watir/js_execution.rb

@@ -33,29 +33,40 @@ module Watir
     #   browser.li(id: 'non_link_1').flash
     #   browser.li(id: 'non_link_1').flash(color: "green", flashes: 3, delay: 0.05)
     #   browser.li(id: 'non_link_1').flash(color: "yellow")
+    #   browser.li(id: 'non_link_1').flash(color: ["yellow", "green"])
     #   browser.li(id: 'non_link_1').flash(flashes: 4)
     #   browser.li(id: 'non_link_1').flash(delay: 0.1)
+    #   browser.li(id: 'non_link_1').flash(:fast)
+    #   browser.li(id: 'non_link_1').flash(:slow)
+    #   browser.li(id: 'non_link_1').flash(:rainbow)
     #
-    # @param [String] color what color to flash with
+    # @param [Symbol] preset :fast, :slow, :long or :rainbow for pre-set values
+    # @param [String/Array] color what 'color' or [colors] to flash with
     # @param [Integer] flashes number of times element should be flashed
     # @param [Integer, Float] delay how long to wait between flashes
     #
     # @return [Watir::Element]
     #
 
-    def flash(color: 'red', flashes: 5, delay: 0.2)
-      background_color = style("backgroundColor")
+    def flash(preset = :default, color: 'red', flashes: 10, delay: 0.1)
+      presets = {
+          fast: { delay: 0.04 },
+          slow: { delay: 0.2 },
+          long: { flashes: 5, delay: 0.5 },
+          rainbow: { flashes: 5, color: %w(red orange yellow green blue indigo violet) }
+      }
+      return self.flash(presets[preset]) unless presets[preset].nil?
+
+      background_color = original_color = style("background-color")
       background_color = 'white' if background_color.empty?
-      element_color = element_call { execute_js(:backgroundColor, @element) }.strip
-      element_color = 'white' if element_color.empty?
+      colors = Array(color).push(background_color)
 
-      (flashes * 2).times do |n|
-        nextcolor = n.even? ? color : background_color
-        element_call { execute_js(:backgroundColor, @element, nextcolor) }
+      (colors * flashes).each do |next_color|
+        element_call { execute_js(:backgroundColor, @element, next_color) }
         sleep(delay)
       end
 
-      element_call { execute_js(:backgroundColor, @element, element_color) }
+      element_call { execute_js(:backgroundColor, @element, original_color) }
 
       self
     end

data/lib/watir/legacy_wait.rb

@@ -83,7 +83,7 @@ module Watir
     def when_present(timeout = nil)
       warning = '#when_present has been deprecated and is unlikely to be needed; '
       warning << 'replace this with #wait_until_present if a wait is still needed'
-      Watir.logger.warn warning
+      Watir.logger.warn warning, ids: [:when_present, :deprecations]
 
       timeout ||= Watir.default_timeout
       message = "waiting for #{selector_string} to become present"
@@ -109,7 +109,8 @@ module Watir
     #
 
     def when_enabled(timeout = nil)
-      Watir.logger.warn '#when_enabled has been deprecated and is unlikely to be needed'
+      Watir.logger.warn '#when_enabled has been deprecated and is unlikely to be needed',
+                        ids: [:when_enabled, :deprecations]
 
       timeout ||= Watir.default_timeout
       message = "waiting for #{selector_string} to become enabled"

data/lib/watir/locators.rb

@@ -26,23 +26,23 @@ module Watir
   module Locators
     module ClassHelpers
       def locator_class
-        class_from_string("#{Watir.locator_namespace}::#{element_class_name}::Locator") ||
+        class_from_string("#{browser.locator_namespace}::#{element_class_name}::Locator") ||
             class_from_string("Watir::Locators::#{element_class_name}::Locator") ||
-            class_from_string("#{Watir.locator_namespace}::Element::Locator") ||
+            class_from_string("#{browser.locator_namespace}::Element::Locator") ||
             Watir::Locators::Element::Locator
       end
 
       def element_validator_class
-        class_from_string("#{Watir.locator_namespace}::#{element_class_name}::Validator") ||
+        class_from_string("#{browser.locator_namespace}::#{element_class_name}::Validator") ||
             class_from_string("Watir::Locators::#{element_class_name}::Validator") ||
-            class_from_string("#{Watir.locator_namespace}::Element::Validator") ||
+            class_from_string("#{browser.locator_namespace}::Element::Validator") ||
             Watir::Locators::Element::Validator
       end
 
       def selector_builder_class
-        class_from_string("#{Watir.locator_namespace}::#{element_class_name}::SelectorBuilder") ||
+        class_from_string("#{browser.locator_namespace}::#{element_class_name}::SelectorBuilder") ||
             class_from_string("Watir::Locators::#{element_class_name}::SelectorBuilder") ||
-            class_from_string("#{Watir.locator_namespace}::Element::SelectorBuilder") ||
+            class_from_string("#{browser.locator_namespace}::Element::SelectorBuilder") ||
             Watir::Locators::Element::SelectorBuilder
       end