watir 6.10.1 → 6.10.2

data/lib/watir/locators.rb

@@ -1,60 +1,60 @@
-require 'watir/locators/element/locator'
-require 'watir/locators/element/selector_builder'
-require 'watir/locators/element/selector_builder/xpath'
-require 'watir/locators/element/validator'
-
-require 'watir/locators/button/locator'
-require 'watir/locators/button/selector_builder'
-require 'watir/locators/button/selector_builder/xpath'
-require 'watir/locators/button/validator'
-
-require 'watir/locators/cell/locator'
-require 'watir/locators/cell/selector_builder'
-
-require 'watir/locators/row/locator'
-require 'watir/locators/row/selector_builder'
-
-require 'watir/locators/text_area/locator'
-require 'watir/locators/text_area/selector_builder'
-
-require 'watir/locators/text_field/locator'
-require 'watir/locators/text_field/selector_builder'
-require 'watir/locators/text_field/selector_builder/xpath'
-require 'watir/locators/text_field/validator'
-
-module Watir
-  module Locators
-    module ClassHelpers
-      def locator_class
-        class_from_string("#{Watir.locator_namespace}::#{element_class_name}::Locator") ||
-            class_from_string("Watir::Locators::#{element_class_name}::Locator") ||
-            class_from_string("#{Watir.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("Watir::Locators::#{element_class_name}::Validator") ||
-            class_from_string("#{Watir.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("Watir::Locators::#{element_class_name}::SelectorBuilder") ||
-            class_from_string("#{Watir.locator_namespace}::Element::SelectorBuilder") ||
-            Watir::Locators::Element::SelectorBuilder
-      end
-
-      def class_from_string(string)
-        Kernel.const_get(string)
-      rescue NameError
-        nil
-      end
-
-      def element_class_name
-        element_class.to_s.split('::').last
-      end
-    end
-  end
-end
+require 'watir/locators/element/locator'
+require 'watir/locators/element/selector_builder'
+require 'watir/locators/element/selector_builder/xpath'
+require 'watir/locators/element/validator'
+
+require 'watir/locators/button/locator'
+require 'watir/locators/button/selector_builder'
+require 'watir/locators/button/selector_builder/xpath'
+require 'watir/locators/button/validator'
+
+require 'watir/locators/cell/locator'
+require 'watir/locators/cell/selector_builder'
+
+require 'watir/locators/row/locator'
+require 'watir/locators/row/selector_builder'
+
+require 'watir/locators/text_area/locator'
+require 'watir/locators/text_area/selector_builder'
+
+require 'watir/locators/text_field/locator'
+require 'watir/locators/text_field/selector_builder'
+require 'watir/locators/text_field/selector_builder/xpath'
+require 'watir/locators/text_field/validator'
+
+module Watir
+  module Locators
+    module ClassHelpers
+      def locator_class
+        class_from_string("#{Watir.locator_namespace}::#{element_class_name}::Locator") ||
+            class_from_string("Watir::Locators::#{element_class_name}::Locator") ||
+            class_from_string("#{Watir.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("Watir::Locators::#{element_class_name}::Validator") ||
+            class_from_string("#{Watir.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("Watir::Locators::#{element_class_name}::SelectorBuilder") ||
+            class_from_string("#{Watir.locator_namespace}::Element::SelectorBuilder") ||
+            Watir::Locators::Element::SelectorBuilder
+      end
+
+      def class_from_string(string)
+        Kernel.const_get(string)
+      rescue NameError
+        nil
+      end
+
+      def element_class_name
+        element_class.to_s.split('::').last
+      end
+    end
+  end
+end

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

@@ -1,31 +1,31 @@
-module Watir
-  module Locators
-    class Button
-      class Locator < Element::Locator
-
-
-        private
-
-        def using_selenium(*)
-          # force watir usage
-        end
-
-        def can_convert_regexp_to_contains?
-          # regexp conversion won't work with the complex xpath selector
-          false
-        end
-
-        def matches_selector?(element, selector)
-          if selector.key?(:value)
-            copy  = selector.dup
-            value = copy.delete(:value)
-
-            super(element, copy) && (value === fetch_value(element, :value) || value === fetch_value(element, :text))
-          else
-            super
-          end
-        end
-      end
-    end
-  end
-end
+module Watir
+  module Locators
+    class Button
+      class Locator < Element::Locator
+
+
+        private
+
+        def using_selenium(*)
+          # force watir usage
+        end
+
+        def can_convert_regexp_to_contains?
+          # regexp conversion won't work with the complex xpath selector
+          false
+        end
+
+        def matches_selector?(element, selector)
+          if selector.key?(:value)
+            copy  = selector.dup
+            value = copy.delete(:value)
+
+            super(element, copy) && (value === fetch_value(element, :value) || value === fetch_value(element, :text))
+          else
+            super
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,30 +1,30 @@
-module Watir
-  module Locators
-    class Button
-      class SelectorBuilder < Element::SelectorBuilder
-        def build_wd_selector(selectors)
-          return if selectors.values.any? { |e| e.kind_of? Regexp }
-
-          selectors.delete(:tag_name) || raise("internal error: no tag_name?!")
-
-          button_attr_exp = xpath_builder.attribute_expression(:button, selectors)
-          
-          xpath = ".//button"
-          xpath << "[#{button_attr_exp}]" unless button_attr_exp.empty?
-          
-          unless selectors[:type] == false
-            selectors[:type] = Watir::Button::VALID_TYPES if [nil, true].include?(selectors[:type])
-            input_attr_exp = xpath_builder.attribute_expression(:input, selectors)
-            
-            xpath << " | .//input"
-            xpath << "[#{input_attr_exp}]"
-          end
-          
-          p build_wd_selector: xpath if $DEBUG
-
-          [:xpath, xpath]
-        end
-      end
-    end
-  end
-end
+module Watir
+  module Locators
+    class Button
+      class SelectorBuilder < Element::SelectorBuilder
+        def build_wd_selector(selectors)
+          return if selectors.values.any? { |e| e.kind_of? Regexp }
+
+          selectors.delete(:tag_name) || raise("internal error: no tag_name?!")
+
+          button_attr_exp = xpath_builder.attribute_expression(:button, selectors)
+          
+          xpath = ".//button"
+          xpath << "[#{button_attr_exp}]" unless button_attr_exp.empty?
+          
+          unless selectors[:type] == false
+            selectors[:type] = Watir::Button::VALID_TYPES if [nil, true].include?(selectors[:type])
+            input_attr_exp = xpath_builder.attribute_expression(:input, selectors)
+            
+            xpath << " | .//input"
+            xpath << "[#{input_attr_exp}]"
+          end
+          
+          p build_wd_selector: xpath if $DEBUG
+
+          [:xpath, xpath]
+        end
+      end
+    end
+  end
+end

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

@@ -1,29 +1,29 @@
-module Watir
-  module Locators
-    class Button
-      class SelectorBuilder
-        class XPath < Element::SelectorBuilder::XPath
-          def lhs_for(building, key)
-            if building == :input && key == :text
-              "@value"
-            else
-              super
-            end
-          end
-
-          private
-
-          def equal_pair(building, key, value)
-            if building == :button && key == :value
-              # :value should look for both node text and @value attribute
-              text = XpathSupport.escape(value)
-              "(text()=#{text} or @value=#{text})"
-            else
-              super
-            end
-          end
-        end
-      end
-    end
-  end
-end
+module Watir
+  module Locators
+    class Button
+      class SelectorBuilder
+        class XPath < Element::SelectorBuilder::XPath
+          def lhs_for(building, key)
+            if building == :input && key == :text
+              "@value"
+            else
+              super
+            end
+          end
+
+          private
+
+          def equal_pair(building, key, value)
+            if building == :button && key == :value
+              # :value should look for both node text and @value attribute
+              text = XpathSupport.escape(value)
+              "(text()=#{text} or @value=#{text})"
+            else
+              super
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/watir/locators/button/validator.rb

@@ -1,15 +1,15 @@
-module Watir
-  module Locators
-    class Button
-      class Validator < Element::Validator
-        def validate(element, _selector)
-          return unless %w[input button].include?(element.tag_name.downcase)
-          # TODO - Verify this is desired behavior based on https://bugzilla.mozilla.org/show_bug.cgi?id=1290963
-          return if element.tag_name.downcase == "input" && !Watir::Button::VALID_TYPES.include?(element.attribute(:type).downcase)
-
-          element
-        end
-      end
-    end
-  end
-end
+module Watir
+  module Locators
+    class Button
+      class Validator < Element::Validator
+        def validate(element, _selector)
+          return unless %w[input button].include?(element.tag_name.downcase)
+          # TODO - Verify this is desired behavior based on https://bugzilla.mozilla.org/show_bug.cgi?id=1290963
+          return if element.tag_name.downcase == "input" && !Watir::Button::VALID_TYPES.include?(element.attribute(:type).downcase)
+
+          element
+        end
+      end
+    end
+  end
+end

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

@@ -1,15 +1,15 @@
-module Watir
-  module Locators
-    class Cell
-      class Locator < Element::Locator
-
-        private
-
-        def using_selenium(*)
-          # force watir usage
-        end
-
-      end
-    end
-  end
-end
+module Watir
+  module Locators
+    class Cell
+      class Locator < Element::Locator
+
+        private
+
+        def using_selenium(*)
+          # force watir usage
+        end
+
+      end
+    end
+  end
+end

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

@@ -1,24 +1,24 @@
-module Watir
-  module Locators
-    class Cell
-      class SelectorBuilder < Element::SelectorBuilder
-        def build_wd_selector(selectors)
-          return if selectors.values.any? { |e| e.kind_of? Regexp }
-
-          expressions = %w[./th ./td]
-          attr_expr = xpath_builder.attribute_expression(nil, selectors)
-
-          unless attr_expr.empty?
-            expressions.map! { |e| "#{e}[#{attr_expr}]" }
-          end
-
-          xpath = expressions.join(" | ")
-
-          p build_wd_selector: xpath if $DEBUG
-
-          [:xpath, xpath]
-        end
-      end
-    end
-  end
-end
+module Watir
+  module Locators
+    class Cell
+      class SelectorBuilder < Element::SelectorBuilder
+        def build_wd_selector(selectors)
+          return if selectors.values.any? { |e| e.kind_of? Regexp }
+
+          expressions = %w[./th ./td]
+          attr_expr = xpath_builder.attribute_expression(nil, selectors)
+
+          unless attr_expr.empty?
+            expressions.map! { |e| "#{e}[#{attr_expr}]" }
+          end
+
+          xpath = expressions.join(" | ")
+
+          p build_wd_selector: xpath if $DEBUG
+
+          [:xpath, xpath]
+        end
+      end
+    end
+  end
+end

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

@@ -1,150 +1,150 @@
-module Watir
-  module Locators
-    class Element
-      class SelectorBuilder
-        attr_reader :custom_attributes
-
-        VALID_WHATS = [Array, String, Regexp, TrueClass, FalseClass, ::Symbol].freeze
-        WILDCARD_ATTRIBUTE = /^(aria|data)_(.+)$/
-
-        def initialize(query_scope, selector, valid_attributes)
-          @query_scope = query_scope # either element or browser
-          @selector = selector
-          @valid_attributes = valid_attributes
-          @custom_attributes = []
-        end
-
-        def normalized_selector
-          selector = {}
-
-          @selector.each do |how, what|
-            check_type(how, what)
-
-            how, what = normalize_selector(how, what)
-            selector[how] = what
-          end
-
-          selector
-        end
-
-        def check_type(how, what)
-          case how
-          when :index
-            unless what.is_a?(Integer)
-              raise TypeError, "expected Integer, got #{what.inspect}:#{what.class}"
-            end
-          when :visible
-            unless what.is_a?(TrueClass) || what.is_a?(FalseClass)
-              raise TypeError, "expected TrueClass or FalseClass, got #{what.inspect}:#{what.class}"
-            end
-          when :visible_text
-            unless what.is_a?(String) || what.is_a?(Regexp)
-              raise TypeError, "expected String or Regexp, got #{what.inspect}:#{what.class}"
-            end
-          else
-            if what.is_a?(Array) && how != :class && how != :class_name
-              raise TypeError, "Only :class locator can have a value of an Array"
-            end
-            if what.is_a?(Symbol) && how != :adjacent
-              raise TypeError, "Symbol is not a valid value"
-            end
-            unless VALID_WHATS.any? { |t| what.is_a? t }
-              raise TypeError, "expected one of #{VALID_WHATS.inspect}, got #{what.inspect}:#{what.class}"
-            end
-          end
-        end
-
-        def should_use_label_element?
-          !valid_attribute?(:label)
-        end
-
-        def build(selector)
-          return given_xpath_or_css(selector) if selector.key?(:xpath) || selector.key?(:css)
-          built = build_wd_selector(selector)
-          Watir.logger.debug "Converted #{selector.inspect} to #{built}"
-          built
-        end
-
-        def xpath_builder
-          @xpath_builder ||= xpath_builder_class.new(should_use_label_element?)
-        end
-
-        private
-
-        def normalize_selector(how, what)
-          case how
-          when :tag_name, :text, :xpath, :index, :class, :label, :css, :visible, :visible_text, :adjacent
-            # include :class since the valid attribute is 'class_name'
-            # include :for since the valid attribute is 'html_for'
-            [how, what]
-          when :class_name
-            [:class, what]
-          when :caption
-            [:text, what]
-          else
-            check_custom_attribute how
-            [how, what]
-          end
-        end
-
-        def check_custom_attribute(attribute)
-          return if valid_attribute?(attribute) || attribute.to_s =~ WILDCARD_ATTRIBUTE
-          @custom_attributes << attribute.to_s
-        end
-
-        def given_xpath_or_css(selector)
-          xpath = selector.delete(:xpath)
-          css   = selector.delete(:css)
-          return unless xpath || css
-
-          if xpath && css
-            raise ArgumentError, ":xpath and :css cannot be combined (#{selector.inspect})"
-          end
-
-          how, what = if xpath
-                        [:xpath, xpath]
-                      elsif css
-                        [:css, css]
-                      end
-
-          if selector.any? && !can_be_combined_with_xpath_or_css?(selector)
-            raise ArgumentError, "#{how} cannot be combined with other selectors (#{selector.inspect})"
-          end
-
-          [how, what]
-        end
-
-        def build_wd_selector(selectors)
-          return if selectors.values.any? { |e| e.is_a? Regexp }
-          build_xpath(selectors)
-        end
-
-        def valid_attribute?(attribute)
-          @valid_attributes && @valid_attributes.include?(attribute)
-        end
-
-        def can_be_combined_with_xpath_or_css?(selector)
-          keys = selector.keys
-          return true if keys == [:tag_name]
-
-          if selector[:tag_name] == "input"
-            return keys.sort == [:tag_name, :type]
-          end
-
-          false
-        end
-
-        def build_xpath(selectors)
-          xpath_builder.build(selectors)
-        end
-
-        def xpath_builder_class
-          Kernel.const_get("#{self.class.name}::XPath")
-        rescue
-          XPath
-        end
-
-      end
-    end
-  end
-end
+module Watir
+  module Locators
+    class Element
+      class SelectorBuilder
+        attr_reader :custom_attributes
+
+        VALID_WHATS = [Array, String, Regexp, TrueClass, FalseClass, ::Symbol].freeze
+        WILDCARD_ATTRIBUTE = /^(aria|data)_(.+)$/
+
+        def initialize(query_scope, selector, valid_attributes)
+          @query_scope = query_scope # either element or browser
+          @selector = selector
+          @valid_attributes = valid_attributes
+          @custom_attributes = []
+        end
+
+        def normalized_selector
+          selector = {}
+
+          @selector.each do |how, what|
+            check_type(how, what)
+
+            how, what = normalize_selector(how, what)
+            selector[how] = what
+          end
+
+          selector
+        end
+
+        def check_type(how, what)
+          case how
+          when :index
+            unless what.is_a?(Integer)
+              raise TypeError, "expected Integer, got #{what.inspect}:#{what.class}"
+            end
+          when :visible
+            unless what.is_a?(TrueClass) || what.is_a?(FalseClass)
+              raise TypeError, "expected TrueClass or FalseClass, got #{what.inspect}:#{what.class}"
+            end
+          when :visible_text
+            unless what.is_a?(String) || what.is_a?(Regexp)
+              raise TypeError, "expected String or Regexp, got #{what.inspect}:#{what.class}"
+            end
+          else
+            if what.is_a?(Array) && how != :class && how != :class_name
+              raise TypeError, "Only :class locator can have a value of an Array"
+            end
+            if what.is_a?(Symbol) && how != :adjacent
+              raise TypeError, "Symbol is not a valid value"
+            end
+            unless VALID_WHATS.any? { |t| what.is_a? t }
+              raise TypeError, "expected one of #{VALID_WHATS.inspect}, got #{what.inspect}:#{what.class}"
+            end
+          end
+        end
+
+        def should_use_label_element?
+          !valid_attribute?(:label)
+        end
+
+        def build(selector)
+          return given_xpath_or_css(selector) if selector.key?(:xpath) || selector.key?(:css)
+          built = build_wd_selector(selector)
+          Watir.logger.debug "Converted #{selector.inspect} to #{built}"
+          built
+        end
+
+        def xpath_builder
+          @xpath_builder ||= xpath_builder_class.new(should_use_label_element?)
+        end
+
+        private
+
+        def normalize_selector(how, what)
+          case how
+          when :tag_name, :text, :xpath, :index, :class, :label, :css, :visible, :visible_text, :adjacent
+            # include :class since the valid attribute is 'class_name'
+            # include :for since the valid attribute is 'html_for'
+            [how, what]
+          when :class_name
+            [:class, what]
+          when :caption
+            [:text, what]
+          else
+            check_custom_attribute how
+            [how, what]
+          end
+        end
+
+        def check_custom_attribute(attribute)
+          return if valid_attribute?(attribute) || attribute.to_s =~ WILDCARD_ATTRIBUTE
+          @custom_attributes << attribute.to_s
+        end
+
+        def given_xpath_or_css(selector)
+          xpath = selector.delete(:xpath)
+          css   = selector.delete(:css)
+          return unless xpath || css
+
+          if xpath && css
+            raise ArgumentError, ":xpath and :css cannot be combined (#{selector.inspect})"
+          end
+
+          how, what = if xpath
+                        [:xpath, xpath]
+                      elsif css
+                        [:css, css]
+                      end
+
+          if selector.any? && !can_be_combined_with_xpath_or_css?(selector)
+            raise ArgumentError, "#{how} cannot be combined with other selectors (#{selector.inspect})"
+          end
+
+          [how, what]
+        end
+
+        def build_wd_selector(selectors)
+          return if selectors.values.any? { |e| e.is_a? Regexp }
+          build_xpath(selectors)
+        end
+
+        def valid_attribute?(attribute)
+          @valid_attributes && @valid_attributes.include?(attribute)
+        end
+
+        def can_be_combined_with_xpath_or_css?(selector)
+          keys = selector.keys
+          return true if keys == [:tag_name]
+
+          if selector[:tag_name] == "input"
+            return keys.sort == [:tag_name, :type]
+          end
+
+          false
+        end
+
+        def build_xpath(selectors)
+          xpath_builder.build(selectors)
+        end
+
+        def xpath_builder_class
+          Kernel.const_get("#{self.class.name}::XPath")
+        rescue
+          XPath
+        end
+
+      end
+    end
+  end
+end