watir 5.0.0 → 6.0.0.beta1

data/lib/watir/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/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/issues/72
+              XpathSupport.downcase('@type')
+            else
+              "@#{key.to_s.tr("_", "-")}"
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+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'
+            # TODO - Verify this is desired behavior based on https://bugzilla.mozilla.org/show_bug.cgi?id=1290963
+            return if selector[:type] && selector[:type] != element.attribute(:type).downcase
+          end
+
+          element
+        end
+      end
+    end
+  end
+end

data/lib/watir/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/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/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/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 Selenium 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/locators/text_field/locator.rb

@@ -0,0 +1,44 @@
+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))
+            if element.tag_name.downcase == 'textarea'
+              warn "Locating textareas with '#text_field' is deprecated. Please, use '#textarea' method instead."
+            end
+            element
+          end
+        end
+      end
+    end
+  end
+end

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

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

@@ -0,0 +1,19 @@
+module Watir
+  module Locators
+    class TextField
+      class SelectorBuilder
+        class XPath < Element::SelectorBuilder::XPath
+          def lhs_for(building, key)
+            if building == :input && key == :text
+              "@value"
+            elsif building == :textarea && key == :value
+              "text()"
+            else
+              super
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+module Watir
+  module Locators
+    class TextField
+      class Validator < Element::Validator
+        VALID_TEXT_FIELD_TAGS = %w[input textarea]
+
+        def validate(element, selector)
+          element_tag_name = element.tag_name.downcase
+
+          if element.tag_name.downcase == 'textarea'
+            warn "Locating textareas with '#text_field' is deprecated. Please, use '#textarea' method instead."
+          end
+          return unless VALID_TEXT_FIELD_TAGS.include?(element_tag_name)
+
+          element
+        end
+      end
+    end
+  end
+end

data/lib/watir/row_container.rb

@@ -0,0 +1,36 @@
+module Watir
+  module RowContainer
+
+    #
+    # Returns table row.
+    #
+
+    def row(*args)
+      Row.new(self, extract_selector(args).merge(tag_name: "tr"))
+    end
+
+    #
+    # Returns table rows collection.
+    #
+
+    def rows(*args)
+      RowCollection.new(self, extract_selector(args).merge(tag_name: "tr"))
+    end
+
+    #
+    # The table as a 2D Array of strings with the text of each cell.
+    #
+    # @return [Array<Array<String>>]
+    #
+
+    def strings
+      assert_exists
+
+      rows.inject [] do |res, row|
+        res << row.cells.map(&:text)
+      end
+    end
+    alias_method :to_a, :strings
+
+  end # RowContainer
+end # Watir

data/lib/watir/screenshot.rb

@@ -0,0 +1,50 @@
+module Watir
+  class Screenshot
+
+    def initialize(driver)
+      @driver = driver
+    end
+
+    #
+    # Saves screenshot to given path.
+    #
+    # @example
+    #   browser.screenshot.save "screenshot.png"
+    #
+    # @param [String] path
+    #
+
+    def save(path)
+      @driver.save_screenshot(path)
+    end
+
+    #
+    # Represents screenshot as PNG image string.
+    #
+    # @example
+    #   browser.screenshot.png
+    #   #=> '\x95\xC7\x8C@1\xC07\x1C(Edb\x15\xB2\vL'
+    #
+    # @return [String]
+    #
+
+    def png
+      @driver.screenshot_as(:png)
+    end
+
+    #
+    # Represents screenshot as Base64 encoded string.
+    #
+    # @example
+    #   browser.screenshot.base64
+    #   #=> '7HWJ43tZDscPleeUuPW6HhN3x+z7vU/lufmH0qNTtTum94IBWMT46evImci1vnFGT'
+    #
+    # @return [String]
+    #
+
+    def base64
+      @driver.screenshot_as(:base64)
+    end
+
+  end # Screenshot
+end # Watir