watir 6.16.2 → 6.18.0

data/lib/watir/elements/file_field.rb

@@ -12,6 +12,7 @@ module Watir
 
       self.value = path
     end
+    alias upload set
 
     #
     # Sets the file field to the given path

data/lib/watir/elements/html_elements.rb

@@ -272,7 +272,6 @@ module Watir
     attribute(String, :form, :form)
     attribute(String, :label, :label)
     attribute("Boolean", :defaultselected?, :defaultSelected)
-    attribute("Boolean", :selected?, :selected)
     attribute(String, :value, :value)
     attribute(Integer, :index, :index)
   end

data/lib/watir/elements/iframe.rb

@@ -44,8 +44,9 @@ module Watir
     # @see Watir::Browser#execute_script
     #
 
-    def execute_script(script, *args)
+    def execute_script(script, *args, function_name: nil)
       args.map! do |e|
+        Watir.logger.info "Executing Script on Frame: #{function_name}" if function_name
         e.is_a?(Element) ? e.wait_until(&:exists?).wd : e
       end
       returned = driver.execute_script(script, *args)
@@ -134,8 +135,8 @@ module Watir
       @element
     end
 
-    def respond_to_missing?(meth, _include_private = false)
-      @driver.respond_to?(meth) || @element.respond_to?(meth) || super
+    def respond_to_missing?(meth, _include_private)
+      @driver.respond_to?(meth) || @element.respond_to?(meth) || super(meth, false)
     end
 
     def method_missing(meth, *args, &blk)

data/lib/watir/elements/link.rb

@@ -3,13 +3,4 @@ module Watir
     alias link a
     alias links as
   end # Container
-
-  class Anchor < HTMLElement
-    #
-    # @todo temporarily add href attribute
-    #
-    # @see https://www.w3.org/Bugs/Public/show_bug.cgi?id=23192
-    #
-    attribute String, :href, :href
-  end # Anchor
 end # Watir

data/lib/watir/elements/radio.rb

@@ -33,7 +33,7 @@ module Watir
     #
 
     def text
-      l = label()
+      l = label
       l.exist? ? l.text : ''
     end
   end # Radio

data/lib/watir/elements/select.rb

@@ -30,8 +30,11 @@ module Watir
     #
 
     def select(*str_or_rx)
-      results = str_or_rx.flatten.map { |v| select_by v }
-      results.first
+      if str_or_rx.size > 1 || str_or_rx.first.is_a?(Array)
+        str_or_rx.flatten.map { |v| select_all_by v }.first
+      else
+        str_or_rx.flatten.map { |v| select_by v }.first
+      end
     end
 
     #
@@ -43,6 +46,10 @@ module Watir
     #
 
     def select_all(*str_or_rx)
+      Watir.logger.deprecate('#select_all',
+                             '#select with an Array instance',
+                             ids: [:select_all])
+
       results = str_or_rx.flatten.map { |v| select_all_by v }
       results.first
     end
@@ -55,8 +62,11 @@ module Watir
     #
 
     def select!(*str_or_rx)
-      results = str_or_rx.flatten.map { |v| select_by!(v, :single) }
-      results.first
+      if str_or_rx.size > 1 || str_or_rx.first.is_a?(Array)
+        str_or_rx.flatten.map { |v| select_by! v, :multiple }.first
+      else
+        str_or_rx.flatten.map { |v| select_by! v, :single }.first
+      end
     end
 
     #
@@ -67,6 +77,10 @@ module Watir
     #
 
     def select_all!(*str_or_rx)
+      Watir.logger.deprecate('#select_all!',
+                             '#select! with an Array instance',
+                             ids: [:select_all])
+
       results = str_or_rx.flatten.map { |v| select_by!(v, :multiple) }
       results.first
     end
@@ -145,7 +159,8 @@ module Watir
       found = find_options(:value, str_or_rx)
 
       if found.size > 1
-        Watir.logger.deprecate 'Selecting Multiple Options with #select', '#select_all',
+        Watir.logger.deprecate 'Selecting multiple options with #select using a String or Regexp value',
+                               '#select with the desired values in an Array instance',
                                ids: [:select_by]
       end
       select_matching(found)
@@ -170,8 +185,8 @@ module Watir
         str_or_rx.inspect.sub('\\A', '^')
                  .sub('\\Z', '$')
                  .sub('\\z', '$')
-                 .sub(%r{^\/}, '')
-                 .sub(%r{\/[a-z]*$}, '')
+                 .sub(%r{^/}, '')
+                 .sub(%r{/[a-z]*$}, '')
                  .gsub(/\(\?#.+\)/, '')
                  .gsub(/\(\?-\w+:/, '(')
       else

data/lib/watir/generator/base/spec_extractor.rb

@@ -109,8 +109,8 @@ module Watir
             begin
               intf = fetch_interface(implementor_name).first
               intf.implements << fetch_interface(implementee_name).first
-            rescue InterfaceNotFound => ex
-              puts ex.message
+            rescue InterfaceNotFound => e
+              puts e.message
             end
           end
         end
@@ -123,8 +123,8 @@ module Watir
             begin
               intf = fetch_interface(includer_name).first
               intf.includes << fetch_interface(includee_name).first
-            rescue InterfaceNotFound => ex
-              puts ex.message
+            rescue InterfaceNotFound => e
+              puts e.message
             end
           end
         end

data/lib/watir/generator/html/generator.rb

@@ -14,7 +14,7 @@ module Watir
       end
 
       def ignored_attributes
-        %w[cells elements hash rows span text size selected? style width height tHead tFoot link options]
+        %w[cells elements hash rows span text size selected? style width height tHead tFoot link options selected]
       end
 
       def generator_implementation

data/lib/watir/has_window.rb

@@ -10,13 +10,7 @@ module Watir
     #
 
     def windows(*args)
-      all = @driver.window_handles.map { |handle| Window.new(self, handle: handle) }
-
-      if args.empty?
-        all
-      else
-        filter_windows extract_selector(args), all
-      end
+      WindowCollection.new self, extract_selector(args)
     end
 
     #
@@ -51,16 +45,24 @@ module Watir
       @original_window ||= window
     end
 
-    private
+    #
+    # Waits for and returns second window if present
+    # See Window#use
+    #
+    # @example
+    #   browser.switch_window
+    #
+    # @return [Window]
+    #
 
-    def filter_windows(selector, windows)
-      unless selector.keys.all? { |k| %i[title url].include? k }
-        raise ArgumentError, "invalid window selector: #{selector.inspect}"
-      end
+    def switch_window
+      current_window = window
+      wins = windows
+      wait_until { (wins = windows) && wins.size > 1 } if wins.size == 1
+      raise StandardError, 'Unable to determine which window to switch to' if wins.size > 2
 
-      windows.select do |win|
-        selector.all? { |key, value| win.send(key) =~ /#{value}/ }
-      end
+      wins.find { |w| w != current_window }.use
+      window
     end
   end # HasWindow
 end # Watir

data/lib/watir/js_execution.rb

@@ -3,8 +3,8 @@ module Watir
     #
     # Delegates script execution to Browser or IFrame.
     #
-    def execute_script(script, *args)
-      @query_scope.execute_script(script, *args)
+    def execute_script(script, *args, function_name: nil)
+      @query_scope.execute_script(script, *args, function_name: function_name)
     end
 
     #
@@ -54,7 +54,7 @@ module Watir
         long: {flashes: 5, delay: 0.5},
         rainbow: {flashes: 5, color: %w[red orange yellow green blue indigo violet]}
       }
-      return flash(presets[preset]) unless presets[preset].nil?
+      return flash(**presets[preset]) unless presets[preset].nil?
 
       background_color = original_color = style('background-color')
       background_color = 'white' if background_color.empty?

data/lib/watir/js_snippets.rb

@@ -6,11 +6,11 @@ module Watir
 
     def execute_js(function_name, *arguments)
       file = File.expand_path("../js_snippets/#{function_name}.js", __FILE__)
-      raise Exception::Error, "Can not excute script as #{function_name}.js does not exist" unless File.exist?(file)
+      raise Exception::Error, "Can not execute script as #{function_name}.js does not exist" unless File.exist?(file)
 
       js = File.read(file)
       script = "return (#{js}).apply(null, arguments)"
-      @query_scope.execute_script(script, *arguments)
+      @query_scope.execute_script(script, *arguments, function_name: function_name)
     end
   end # JSSnippets
 end # Watir

data/lib/watir/legacy_wait.rb

@@ -10,7 +10,7 @@ module Watir
     end
 
     def respond_to_missing?(*args)
-      @element.respond_to?(*args)
+      @element.respond_to?(*args) || super
     end
 
     def method_missing(method, *args, &block)

data/lib/watir/locators.rb

@@ -55,9 +55,7 @@ module Watir
       end
 
       def class_from_string(string)
-        Kernel.const_get(string)
-      rescue NameError
-        nil
+        Watir.const_get(string) if Watir.const_defined?(string)
       end
 
       def element_class_name

data/lib/watir/locators/element/locator.rb

@@ -15,7 +15,8 @@ module Watir
         def locate(built)
           @built = built.dup
           @driver_scope = locator_scope.wd
-          matching_elements(@built, :first)
+          @filter = :first
+          matching_elements
         rescue Selenium::WebDriver::Error::NoSuchElementError
           nil
         end
@@ -23,37 +24,46 @@ module Watir
         def locate_all(built)
           @built = built.dup
           @driver_scope = locator_scope.wd
-          raise ArgumentError, "can't locate all elements by :index" if built.key?(:index)
+          @filter = :all
 
-          [matching_elements(@built, :all)].flatten
+          return [matching_elements].flatten unless @built.key?(:index)
+
+          raise ArgumentError, "can't locate all elements by :index"
         end
 
         private
 
-        def matching_elements(built, filter)
-          return locate_element(*built.to_a.flatten) if built.size == 1 && filter == :first
-
-          wd_locator_key = (Watir::Locators::W3C_FINDERS & built.keys).first
-          wd_locator = built.select { |k, _v| wd_locator_key == k }
-          match_values = built.reject { |k, _v| wd_locator_key == k }
+        def matching_elements
+          return locate_element(*@built.to_a.flatten) if @built.size == 1 && @filter == :first
 
           # TODO: Wrap this to continue trying until default timeout
           retries = 0
           begin
             elements = locate_elements(*wd_locator.to_a.flatten)
 
-            element_matcher.match(elements, match_values, filter)
+            element_matcher.match(elements, match_values, @filter)
           rescue Selenium::WebDriver::Error::StaleElementReferenceError
             retries += 1
             sleep 0.5
             retry unless retries > 2
-            target = filter == :all ? 'element collection' : 'element'
+            target = @filter == :all ? 'element collection' : 'element'
             raise LocatorException, "Unable to locate #{target} from #{@selector} due to changing page"
           end
         end
 
+        def wd_locator
+          # SelectorBuilder only allows one of these
+          wd_locator_key = (Watir::Locators::W3C_FINDERS & @built.keys).first
+          @wd_locator ||= @built.select { |k, _v| wd_locator_key == k }
+        end
+
+        def match_values
+          @match_values ||= @built.reject { |k, _v| wd_locator.keys.first == k }
+        end
+
         def locator_scope
-          @built.delete(:scope) || @query_scope.browser
+          scope = @built.delete(:scope)
+          @locator_scope ||= scope || @query_scope.browser
         end
 
         def locate_element(how, what, scope = driver_scope)

data/lib/watir/locators/element/selector_builder.rb

@@ -6,11 +6,10 @@ module Watir
         attr_reader :custom_attributes, :built
 
         WILDCARD_ATTRIBUTE = /^(aria|data)_(.+)$/.freeze
-        INTEGER_CLASS = Gem::Version.new(RUBY_VERSION) < Gem::Version.new('2.4') ? Fixnum : Integer
         VALID_WHATS = Hash.new([String, Regexp, TrueClass, FalseClass]).merge(adjacent: [::Symbol],
                                                                               xpath: [String],
                                                                               css: [String],
-                                                                              index: [INTEGER_CLASS],
+                                                                              index: [Integer],
                                                                               visible: [TrueClass, FalseClass],
                                                                               tag_name: [String, Regexp, ::Symbol],
                                                                               visible_text: [String, Regexp],
@@ -53,11 +52,7 @@ module Watir
           if @selector.key?(:class) || @selector.key?(:class_name)
             classes = ([@selector[:class]].flatten + [@selector.delete(:class_name)].flatten).compact
 
-            classes.each do |class_name|
-              next unless class_name.is_a?(String) && class_name.strip.include?(' ')
-
-              deprecate_class_array(class_name)
-            end
+            deprecate_class_array(classes)
 
             @selector[:class] = classes
           end
@@ -83,11 +78,15 @@ module Watir
           scope_invalid_locators.empty?
         end
 
-        def deprecate_class_array(class_name)
-          dep = "Using the :class locator to locate multiple classes with a String value (i.e. \"#{class_name}\")"
-          Watir.logger.deprecate dep,
-                                 "Array (e.g. #{class_name.split})",
-                                 ids: [:class_array]
+        def deprecate_class_array(class_array)
+          class_array.each do |class_name|
+            next unless class_name.is_a?(String) && class_name.strip.include?(' ')
+
+            dep = "Using the :class locator to locate multiple classes with a String value (i.e. \"#{class_name}\")"
+            Watir.logger.deprecate dep,
+                                   "Array (e.g. #{class_name.split})",
+                                   ids: [:class_array]
+          end
         end
 
         def check_type(how, what)
@@ -143,7 +142,7 @@ module Watir
 
         # Extensions implement this method when creating a different selector builder
         def implementation_class
-          Kernel.const_get("#{self.class.name}::XPath")
+          Watir.const_get("#{self.class.name}::XPath")
         end
 
         def build_wd_selector(selector)

data/lib/watir/locators/element/selector_builder/xpath.rb

@@ -12,6 +12,7 @@ module Watir
 
           def build(selector)
             @selector = selector
+            @valid_attributes = build_valid_attributes
 
             @built = (@selector.keys & CAN_NOT_BUILD).each_with_object({}) do |key, hash|
               hash[key] = @selector.delete(key)
@@ -45,9 +46,10 @@ module Watir
           end
 
           def predicate_expression(key, val)
-            if val.eql? true
+            case val
+            when true
               attribute_presence(key)
-            elsif val.eql? false
+            when false
               attribute_absence(key)
             else
               equal_pair(key, val)
@@ -55,11 +57,9 @@ module Watir
           end
 
           def predicate_conversion(key, regexp)
-            # type attributes can be upper case - downcase them
-            # https://github.com/watir/watir/issues/72
-            downcase = key == :type || regexp.casefold?
+            downcase = case_insensitive_attribute?(key) || regexp.casefold?
 
-            lhs = lhs_for(key, downcase)
+            lhs = lhs_for(key, downcase: downcase)
 
             results = RegexpDisassembler.new(regexp).substrings
 
@@ -72,8 +72,10 @@ module Watir
 
             add_to_matching(key, regexp, results)
 
-            results.map { |substring|
-              "contains(#{lhs}, '#{substring}')"
+            results.map { |rhs|
+              rhs = "'#{rhs}'"
+              rhs = XpathSupport.downcase(rhs) if downcase
+              "contains(#{lhs}, #{rhs})"
             }.flatten.compact.join(' and ')
           end
 
@@ -200,7 +202,7 @@ module Watir
             regexp.casefold? ? !results.first.casecmp(regexp.source).zero? : results.first != regexp.source
           end
 
-          def lhs_for(key, downcase = false)
+          def lhs_for(key, downcase: false)
             case key
             when String
               "@#{key}"
@@ -211,7 +213,7 @@ module Watir
             when :text
               'normalize-space()'
             when :contains_text
-              'text()'
+              'normalize-space()'
             when ::Symbol
               lhs = "@#{key.to_s.tr('_', '-')}"
               downcase ? XpathSupport.downcase(lhs) : lhs
@@ -221,11 +223,11 @@ module Watir
           end
 
           def attribute_presence(attribute)
-            lhs_for(attribute, false)
+            lhs_for(attribute)
           end
 
           def attribute_absence(attribute)
-            lhs = lhs_for(attribute, false)
+            lhs = lhs_for(attribute)
             "not(#{lhs})"
           end
 
@@ -236,9 +238,34 @@ module Watir
 
               negate_xpath ? "not(#{expression})" : expression
             else
-              "#{lhs_for(key, key == :type)}=#{XpathSupport.escape value}"
+              downcase = case_insensitive_attribute?(key)
+
+              lhs = lhs_for(key, downcase: downcase)
+              rhs = XpathSupport.escape(value)
+              rhs = XpathSupport.downcase(rhs) if downcase
+
+              "#{lhs}=#{rhs}"
+            end
+          end
+
+          def build_valid_attributes
+            tag_name = @selector[:tag_name]
+            if tag_name.is_a?(String) && Watir.tag_to_class[tag_name.to_sym]
+              Watir.tag_to_class[tag_name.to_sym].attribute_list
+            else
+              Watir::HTMLElement.attribute_list
             end
           end
+
+          def case_insensitive_attribute?(attribute)
+            # type attributes can be upper case - downcase them
+            # https://github.com/watir/watir/issues/72
+            return true if attribute == :type
+            return true if Watir::Element::CASE_INSENSITIVE_ATTRIBUTES.include?(attribute) &&
+                           @valid_attributes.include?(attribute)
+
+            false
+          end
         end
       end
     end