watir 5.0.0 → 6.0.0.beta1

data/lib/watir/locators.rb

@@ -0,0 +1,22 @@
+require 'watir/locators/element/locator'
+require 'watir/locators/element/selector_builder'
+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'

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

@@ -0,0 +1,38 @@
+module Watir
+  module Locators
+    class Button
+      class Locator < Element::Locator
+        def locate_all
+          find_all_by_multiple
+        end
+
+        private
+
+        def wd_find_first_by(how, what)
+          if how == :tag_name
+            how  = :xpath
+            what = ".//button | .//input[#{selector_builder.xpath_builder.attribute_expression(:input, type: Watir::Button::VALID_TYPES)}]"
+          end
+
+          super
+        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

@@ -0,0 +1,27 @@
+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)
+
+          selectors[:type] = Watir::Button::VALID_TYPES
+          input_attr_exp = xpath_builder.attribute_expression(:input, selectors)
+
+          xpath = ".//button"
+          xpath << "[#{button_attr_exp}]" unless button_attr_exp.empty?
+          xpath << " | .//input"
+          xpath << "[#{input_attr_exp}]"
+
+          p build_wd_selector: xpath if $DEBUG
+
+          [:xpath, xpath]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +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

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

@@ -0,0 +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

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

@@ -0,0 +1,17 @@
+module Watir
+  module Locators
+    class Cell
+      class Locator < Element::Locator
+        def locate_all
+          find_all_by_multiple
+        end
+
+        private
+
+        def by_id
+          nil
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +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

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

@@ -0,0 +1,249 @@
+module Watir
+  module Locators
+    class Element
+      class Locator
+        attr_reader :selector_builder
+        attr_reader :element_validator
+
+        WD_FINDERS = [
+          :class,
+          :class_name,
+          :css,
+          :id,
+          :link,
+          :link_text,
+          :name,
+          :partial_link_text,
+          :tag_name,
+          :xpath
+        ]
+
+        # Regular expressions that can be reliably converted to xpath `contains`
+        # expressions in order to optimize the .
+        CONVERTABLE_REGEXP = %r{
+          \A
+            ([^\[\]\\^$.|?*+()]*) # leading literal characters
+            [^|]*?                # do not try to convert expressions with alternates
+            ([^\[\]\\^$.|?*+()]*) # trailing literal characters
+          \z
+        }x
+
+        def initialize(parent, selector, selector_builder, element_validator)
+          @parent = parent # either element or browser
+          @selector = selector.dup
+          @selector_builder = selector_builder
+          @element_validator = element_validator
+        end
+
+        def locate
+          e = by_id and return e # short-circuit if :id is given
+
+          if @selector.size == 1
+            element = find_first_by_one
+          else
+            element = find_first_by_multiple
+          end
+
+          # This actually only applies when finding by xpath/css - browser.text_field(:xpath, "//input[@type='radio']")
+          # We don't need to validate the element if we built the xpath ourselves.
+          # It is also used to alter behavior of methods locating more than one type of element
+          # (e.g. text_field locates both input and textarea)
+          element_validator.validate(element, @selector) if element
+        rescue Selenium::WebDriver::Error::NoSuchElementError, Selenium::WebDriver::Error::StaleElementReferenceError
+          nil
+        end
+
+        def locate_all
+          if @selector.size == 1
+            find_all_by_one
+          else
+            find_all_by_multiple
+          end
+        end
+
+        private
+
+        def by_id
+          return unless id = @selector[:id] and id.is_a? String
+
+          selector = @selector.dup
+          selector.delete(:id)
+
+          tag_name = selector.delete(:tag_name)
+          return unless selector.empty? # multiple attributes
+
+          element = @parent.wd.find_element(:id, id)
+          return if tag_name && !element_validator.validate(element, selector)
+
+          element
+        end
+
+        def find_first_by_one
+          how, what = @selector.to_a.first
+          selector_builder.check_type(how, what)
+
+          if WD_FINDERS.include?(how)
+            wd_find_first_by(how, what)
+          else
+            find_first_by_multiple
+          end
+        end
+
+        def find_first_by_multiple
+          selector = selector_builder.normalized_selector
+
+          idx = selector.delete(:index)
+          how, what = selector_builder.build(selector)
+
+          if how
+            # could build xpath/css for selector
+            if idx
+              @parent.wd.find_elements(how, what)[idx]
+            else
+              @parent.wd.find_element(how, what)
+            end
+          else
+            # can't use xpath, probably a regexp in there
+            if idx
+              wd_find_by_regexp_selector(selector, :select)[idx]
+            else
+              wd_find_by_regexp_selector(selector, :find)
+            end
+          end
+        end
+
+        def find_all_by_one
+          how, what = @selector.to_a.first
+          selector_builder.check_type how, what
+
+          if WD_FINDERS.include?(how)
+            wd_find_all_by(how, what)
+          else
+            find_all_by_multiple
+          end
+        end
+
+        def find_all_by_multiple
+          selector = selector_builder.normalized_selector
+
+          if selector.key? :index
+            raise ArgumentError, "can't locate all elements by :index"
+          end
+
+          how, what = selector_builder.build(selector)
+          if how
+            @parent.wd.find_elements(how, what)
+          else
+            wd_find_by_regexp_selector(selector, :select)
+          end
+        end
+
+        def wd_find_all_by(how, what)
+          if what.is_a? String
+            @parent.wd.find_elements(how, what)
+          else
+            all_elements.select { |element| fetch_value(element, how) =~ what }
+          end
+        end
+
+        def fetch_value(element, how)
+          case how
+          when :text
+            element.text
+          when :tag_name
+            element.tag_name.downcase
+          when :href
+            (href = element.attribute(:href)) && href.strip
+          else
+            element.attribute(how.to_s.tr("_", "-").to_sym)
+          end
+        end
+
+        def all_elements
+          @parent.wd.find_elements(xpath: ".//*")
+        end
+
+        def wd_find_first_by(how, what)
+          if what.is_a? String
+            @parent.wd.find_element(how, what)
+          else
+            all_elements.find { |element| fetch_value(element, how) =~ what }
+          end
+        end
+
+        def wd_find_by_regexp_selector(selector, method = :find)
+          parent = @parent.wd
+          rx_selector = delete_regexps_from(selector)
+
+          if rx_selector.key?(:label) && selector_builder.should_use_label_element?
+            label = label_from_text(rx_selector.delete(:label)) || return
+            if (id = label.attribute(:for))
+              selector[:id] = id
+            else
+              parent = label
+            end
+          end
+
+          how, what = selector_builder.build(selector)
+
+          unless how
+            raise Error, "internal error: unable to build Selenium selector from #{selector.inspect}"
+          end
+
+          if how == :xpath && can_convert_regexp_to_contains?
+            rx_selector.each do |key, value|
+              next if key == :tag_name || key == :text
+
+              predicates = regexp_selector_to_predicates(key, value)
+              what = "(#{what})[#{predicates.join(' and ')}]" unless predicates.empty?
+            end
+          end
+
+          elements = parent.find_elements(how, what)
+          elements.__send__(method) { |el| matches_selector?(el, rx_selector) }
+        end
+
+        def delete_regexps_from(selector)
+          rx_selector = {}
+
+          selector.dup.each do |how, what|
+            next unless what.is_a?(Regexp)
+            rx_selector[how] = what
+            selector.delete how
+          end
+
+          rx_selector
+        end
+
+        def label_from_text(label_exp)
+          # TODO: this won't work correctly if @wd is a sub-element
+          @parent.wd.find_elements(:tag_name, 'label').find do |el|
+            matches_selector?(el, text: label_exp)
+          end
+        end
+
+        def matches_selector?(element, selector)
+          selector.all? do |how, what|
+            what === fetch_value(element, how)
+          end
+        end
+
+        def can_convert_regexp_to_contains?
+          true
+        end
+
+        def regexp_selector_to_predicates(key, re)
+          return [] if re.casefold?
+
+          match = re.source.match(CONVERTABLE_REGEXP)
+          return [] unless match
+
+          lhs = selector_builder.xpath_builder.lhs_for(nil, key)
+          match.captures.reject(&:empty?).map do |literals|
+            "contains(#{lhs}, #{XpathSupport.escape(literals)})"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,147 @@
+require 'watir/locators/element/selector_builder/css'
+require 'watir/locators/element/selector_builder/xpath'
+
+module Watir
+  module Locators
+    class Element
+      class SelectorBuilder
+        VALID_WHATS = [String, Regexp]
+        WILDCARD_ATTRIBUTE = /^(aria|data)_(.+)$/
+
+        def initialize(parent, selector, valid_attributes)
+          @parent = parent # either element or browser
+          @selector = selector
+          @valid_attributes = valid_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?(Fixnum)
+              raise TypeError, "expected Fixnum, got #{what.inspect}:#{what.class}"
+            end
+          else
+            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)
+          given_xpath_or_css(selector) || build_wd_selector(selector)
+        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
+            # 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
+            assert_valid_as_attribute how
+            [how, what]
+          end
+        end
+
+        def assert_valid_as_attribute(attribute)
+          return if valid_attribute?(attribute) || attribute.to_s =~ WILDCARD_ATTRIBUTE
+          raise Exception::MissingWayOfFindingObjectException, "invalid attribute: #{attribute.inspect}"
+        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)
+          unless selectors.values.any? { |e| e.is_a? Regexp }
+            build_css(selectors) || build_xpath(selectors)
+          end
+        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 build_css(selectors)
+          css_builder.build(selectors)
+        end
+
+        def xpath_builder_class
+          Kernel.const_get("#{self.class.name}::XPath")
+        rescue
+          XPath
+        end
+
+        def css_builder
+          @css_builder ||= css_builder_class.new
+        end
+
+        def css_builder_class
+          Kernel.const_get("#{self.class.name}::CSS")
+        rescue
+          CSS
+        end
+      end
+    end
+  end
+end