watir-webdriver 0.9.1 → 0.9.2

data/lib/watir-webdriver/elements/table.rb

@@ -31,7 +31,7 @@ module Watir
     # Returns row of this table with given index.
     #
     # @param [Fixnum] idx
-    # @return Watir::TableRow
+    # @return Watir::Row
     #
 
     def [](idx)

data/lib/watir-webdriver/elements/table_cell.rb

@@ -1,34 +1,6 @@
 module Watir
   class TableCell < HTMLElement
-    # @private
-    attr_writer :locator_class
-
     alias_method :colspan, :col_span
     alias_method :rowspan, :row_span
-
-    def locator_class
-      @locator_class || super
-    end
   end # TableCell
-
-  class TableCellCollection < ElementCollection
-    attr_writer :locator_class
-
-    def locator_class
-      @locator_class || super
-    end
-
-    def elements
-      # we do this craziness since the xpath used will find direct child rows
-      # before any rows inside thead/tbody/tfoot...
-      elements = super
-
-      if locator_class == ChildCellLocator
-        elements = elements.sort_by { |row| row.attribute(:cellIndex).to_i }
-      end
-
-      elements
-    end
-
-  end # TableCellCollection
 end # Watir

data/lib/watir-webdriver/elements/table_row.rb

@@ -2,43 +2,14 @@ module Watir
   class TableRow < HTMLElement
     include CellContainer
 
-    # @private
-    attr_writer :locator_class
-
     #
     # Get the n'th cell (<th> or <td>) of this row
     #
-    # @return Watir::TableCell
+    # @return Watir::Cell
     #
 
     def [](idx)
       cell(:index, idx)
     end
-
-    private
-
-    def locator_class
-      @locator_class || super
-    end
   end # TableRow
-
-  class TableRowCollection < ElementCollection
-    attr_writer :locator_class
-
-    def elements
-      # we do this craziness since the xpath used will find direct child rows
-      # before any rows inside thead/tbody/tfoot...
-      elements = super
-
-      if locator_class == ChildRowLocator and @parent.kind_of? Table
-        elements = elements.sort_by { |row| row.attribute(:rowIndex).to_i }
-      end
-
-      elements
-    end
-
-    def locator_class
-      @locator_class || super
-    end
-  end # TableRowCollection
 end # Watir

data/lib/watir-webdriver/elements/text_area.rb

@@ -1,22 +1,5 @@
 module Watir
   class TextArea < HTMLElement
     include UserEditable
-
-    private
-
-    def locator_class
-      TextAreaLocator
-    end
-
   end # TextArea
-
-  class TextAreaCollection < ElementCollection
-
-    private
-
-    def locator_class
-      TextAreaLocator
-    end
-
-  end # TextAreaCollection
 end # Watir

data/lib/watir-webdriver/elements/text_field.rb

@@ -2,15 +2,13 @@ module Watir
   class TextField < Input
     include UserEditable
 
+    NON_TEXT_TYPES = %w[file radio checkbox submit reset image button hidden datetime date month week time datetime-local range color]
+
     inherit_attributes_from Watir::TextArea
     remove_method :type # we want Input#type here, which was overriden by TextArea's attributes
 
     private
 
-    def locator_class
-      TextFieldLocator
-    end
-
     def selector_string
       selector = @selector.dup
       selector[:type] = '(any text type)'
@@ -32,10 +30,6 @@ module Watir
   class TextFieldCollection < InputCollection
     private
 
-    def locator_class
-      TextFieldLocator
-    end
-
     def element_class
       TextField
     end

data/lib/watir-webdriver/generator/base/visitor.rb

@@ -97,16 +97,7 @@ module Watir
         @already_defined << name
         name = Util.classify(classify_regexp, name)
 
-        [:class, "#{name}Collection", [:const, :ElementCollection],
-          [:scope,
-            [:defn, :element_class,
-              [:args],
-              [:scope,
-                [:block, [:const, name]]
-              ]
-            ]
-          ]
-        ]
+        [:class, "#{name}Collection", [:const, :ElementCollection]]
       end
 
       def attribute_calls(attributes)

data/lib/watir-webdriver/locators.rb

@@ -0,0 +1,22 @@
+require 'watir-webdriver/locators/element/locator'
+require 'watir-webdriver/locators/element/selector_builder'
+require 'watir-webdriver/locators/element/validator'
+
+require 'watir-webdriver/locators/button/locator'
+require 'watir-webdriver/locators/button/selector_builder'
+require 'watir-webdriver/locators/button/selector_builder/xpath'
+require 'watir-webdriver/locators/button/validator'
+
+require 'watir-webdriver/locators/cell/locator'
+require 'watir-webdriver/locators/cell/selector_builder'
+
+require 'watir-webdriver/locators/row/locator'
+require 'watir-webdriver/locators/row/selector_builder'
+
+require 'watir-webdriver/locators/text_area/locator'
+require 'watir-webdriver/locators/text_area/selector_builder'
+
+require 'watir-webdriver/locators/text_field/locator'
+require 'watir-webdriver/locators/text_field/selector_builder'
+require 'watir-webdriver/locators/text_field/selector_builder/xpath'
+require 'watir-webdriver/locators/text_field/validator'

data/lib/watir-webdriver/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-webdriver/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-webdriver/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-webdriver/locators/button/validator.rb

@@ -0,0 +1,14 @@
+module Watir
+  module Locators
+    class Button
+      class Validator < Element::Validator
+        def validate(element, selector)
+          return unless %w[input button].include?(element.tag_name.downcase)
+          return if element.tag_name.downcase == "input" && !Watir::Button::VALID_TYPES.include?(element.attribute(:type))
+
+          element
+        end
+      end
+    end
+  end
+end

data/lib/watir-webdriver/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-webdriver/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-webdriver/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 WebDriver 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