watir-webdriver 0.9.1 → 0.9.2

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

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

data/lib/watir-webdriver/locators/element/selector_builder/css.rb

@@ -0,0 +1,65 @@
+module Watir
+  module Locators
+    class Element
+      class SelectorBuilder
+        class CSS
+          def build(selectors)
+            return unless use_css?(selectors)
+
+            if selectors.empty?
+              css = '*'
+            else
+              css = ''
+              css << (selectors.delete(:tag_name) || '')
+
+              klass = selectors.delete(:class)
+              if klass
+                if klass.include? ' '
+                  css << %([class="#{css_escape klass}"])
+                else
+                  css << ".#{klass}"
+                end
+              end
+
+              href = selectors.delete(:href)
+              if href
+                css << %([href~="#{css_escape href}"])
+              end
+
+              selectors.each do |key, value|
+                key = key.to_s.tr("_", "-")
+                css << %([#{key}="#{css_escape value}"]) # TODO: proper escaping
+              end
+            end
+
+            [:css, css]
+          end
+
+          private
+
+          def use_css?(selectors)
+            return false unless Watir.prefer_css?
+
+            if selectors.key?(:text) || selectors.key?(:label) || selectors.key?(:index)
+              return false
+            end
+
+            if selectors[:tag_name] == 'input' && selectors.key?(:type)
+              return false
+            end
+
+            if selectors.key?(:class) && selectors[:class] !~ /^[\w-]+$/ui
+              return false
+            end
+
+            true
+          end
+
+          def css_escape(str)
+            str.gsub('"', '\\"')
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,72 @@
+module Watir
+  module Locators
+    class Element
+      class SelectorBuilder
+        class XPath
+          def initialize(should_use_label_element)
+            @should_use_label_element = should_use_label_element
+          end
+
+          def build(selectors)
+            xpath = ".//"
+            xpath << (selectors.delete(:tag_name) || '*').to_s
+
+            selectors.delete :index
+
+            # the remaining entries should be attributes
+            unless selectors.empty?
+              xpath << "[" << attribute_expression(nil, selectors) << "]"
+            end
+
+            p xpath: xpath, selectors: selectors if $DEBUG
+
+            [:xpath, xpath]
+          end
+
+          # @todo Get rid of building
+          def attribute_expression(building, selectors)
+            f = selectors.map do |key, val|
+              if val.is_a?(Array)
+                "(" + val.map { |v| equal_pair(building, key, v) }.join(" or ") + ")"
+              else
+                equal_pair(building, key, val)
+              end
+            end
+            f.join(" and ")
+          end
+
+          # @todo Get rid of building
+          def equal_pair(building, key, value)
+            if key == :class
+              klass = XpathSupport.escape " #{value} "
+              "contains(concat(' ', @class, ' '), #{klass})"
+            elsif key == :label && @should_use_label_element
+              # we assume :label means a corresponding label element, not the attribute
+              text = "normalize-space()=#{XpathSupport.escape value}"
+              "(@id=//label[#{text}]/@for or parent::label[#{text}])"
+            else
+              "#{lhs_for(building, key)}=#{XpathSupport.escape value}"
+            end
+          end
+
+          # @todo Get rid of building
+          def lhs_for(_building, key)
+            case key
+            when :text, 'text'
+              'normalize-space()'
+            when :href
+              # TODO: change this behaviour?
+              'normalize-space(@href)'
+            when :type
+              # type attributes can be upper case - downcase them
+              # https://github.com/watir/watir-webdriver/issues/72
+              XpathSupport.downcase('@type')
+            else
+              "@#{key.to_s.tr("_", "-")}"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/watir-webdriver/locators/element/validator.rb

@@ -0,0 +1,22 @@
+module Watir
+  module Locators
+    class Element
+      class Validator
+        def validate(element, selector)
+          selector_tag_name = selector[:tag_name]
+          element_tag_name = element.tag_name.downcase
+
+          if selector_tag_name
+            return unless selector_tag_name === element_tag_name
+          end
+
+          if element_tag_name == 'input'
+            return if selector[:type] && selector[:type] != element.attribute(:type)
+          end
+
+          element
+        end
+      end
+    end
+  end
+end

data/lib/watir-webdriver/locators/row/locator.rb

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

data/lib/watir-webdriver/locators/row/selector_builder.rb

@@ -0,0 +1,29 @@
+module Watir
+  module Locators
+    class Row
+      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?!")
+
+          expressions = %w[./tr]
+          unless %w[tbody tfoot thead].include?(@parent.tag_name.downcase)
+            expressions += %w[./tbody/tr ./thead/tr ./tfoot/tr]
+          end
+
+          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/text_area/locator.rb

@@ -0,0 +1,13 @@
+module Watir
+  module Locators
+    class TextArea
+      class Locator < Element::Locator
+        private
+
+        def can_convert_regexp_to_contains?
+          false
+        end
+      end
+    end
+  end
+end

data/lib/watir-webdriver/locators/text_area/selector_builder.rb

@@ -0,0 +1,22 @@
+module Watir
+  module Locators
+    class TextArea
+      class SelectorBuilder < Element::SelectorBuilder
+        private
+
+        def normalize_selector(how, what)
+          # We need to iterate through located elements and fetch
+          # attribute value using WebDriver because XPath doesn't understand
+          # difference between IDL vs content attribute.
+          # Current Element design doesn't allow to do that in any
+          # obvious way except to use regular expression.
+          if how == :value && what.kind_of?(String)
+            [how, Regexp.new('^' + Regexp.escape(what) + '$')]
+          else
+            super
+          end
+        end
+      end
+    end
+  end
+end

data/lib/watir-webdriver/locators/text_field/locator.rb

@@ -0,0 +1,42 @@
+module Watir
+  module Locators
+    class TextField
+      class Locator < Element::Locator
+        def locate_all
+          find_all_by_multiple
+        end
+
+        private
+
+        def wd_find_first_by(how, what)
+          how, what = selector_builder.build_wd_selector(how => what) if how == :tag_name
+          super
+        end
+
+        def matches_selector?(element, rx_selector)
+          rx_selector = rx_selector.dup
+
+          tag_name = element.tag_name.downcase
+
+          [:text, :value, :label].each do |key|
+            if rx_selector.key?(key)
+              correct_key = tag_name == 'input' ? :value : :text
+              rx_selector[correct_key] = rx_selector.delete(key)
+            end
+          end
+
+          super
+        end
+
+        def by_id
+          element = super
+
+          if element && !Watir::TextField::NON_TEXT_TYPES.include?(element.attribute(:type))
+            warn "Locating textareas with '#text_field' is deprecated. Please, use '#textarea' method instead."
+            element
+          end
+        end
+      end
+    end
+  end
+end

data/lib/watir-webdriver/locators/text_field/selector_builder.rb

@@ -0,0 +1,34 @@
+module Watir
+  module Locators
+    class TextField
+      class SelectorBuilder < Element::SelectorBuilder
+        def build_wd_selector(selectors)
+          return if selectors.values.any? { |e| e.kind_of? Regexp }
+
+          selectors.delete(:tag_name)
+
+          textarea_attr_exp = xpath_builder.attribute_expression(:textarea, selectors)
+          input_attr_exp = xpath_builder.attribute_expression(:input, selectors)
+
+          xpath = ".//input[(not(@type) or (#{negative_type_expr}))"
+          xpath << " and #{input_attr_exp}" unless input_attr_exp.empty?
+          xpath << "] "
+          xpath << "| .//textarea"
+          xpath << "[#{textarea_attr_exp}]" unless textarea_attr_exp.empty?
+
+          p build_wd_selector: xpath if $DEBUG
+
+          [:xpath, xpath]
+        end
+
+        private
+
+        def negative_type_expr
+          Watir::TextField::NON_TEXT_TYPES.map do |type|
+            "%s!=%s" % [XpathSupport.downcase('@type'), type.inspect]
+          end.join(' and ')
+        end
+      end
+    end
+  end
+end