watir-nokogiri 1.0.0

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

@@ -0,0 +1,46 @@
+module WatirNokogiri
+  class TableRow < HTMLElement
+    include CellContainer
+
+    # @private
+    attr_writer :locator_class
+
+    #
+    # Get the n'th cell (<th> or <td>) of this row
+    #
+    # @return Watir::TableCell
+    #
+
+    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
+        # This sorting will not do anything since nokogiri does not know the rowIndex
+        # BUG: https://github.com/jkotests/watir-nokogiri/issues/1
+        elements = elements.sort_by { |row| row.get_attribute(:rowIndex).to_i }
+      end
+
+      elements
+    end
+
+    def locator_class
+      @locator_class || super
+    end
+  end # TableRowCollection
+end # Watir

data/lib/watir-nokogiri/elements/table_section.rb

@@ -0,0 +1,15 @@
+module WatirNokogiri
+  class TableSection < HTMLElement
+    include RowContainer
+
+    #
+    # Returns table section row with given index.
+    #
+    # @param [Fixnum] idx
+    #
+
+    def [](idx)
+      row(:index => idx)
+    end
+  end # TableSection
+end # WatirNokogiri

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

@@ -0,0 +1,22 @@
+module WatirNokogiri
+  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 # WatirNokogiri

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

@@ -0,0 +1,44 @@
+# encoding: utf-8
+module WatirNokogiri
+  class TextField < Input
+    include UserEditable
+
+    attributes WatirNokogiri::TextArea.typed_attributes
+    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)'
+      selector[:tag_name] = "input or textarea"
+      selector.inspect
+    end
+  end # TextField
+
+  module Container
+    def text_field(*args)
+      TextField.new(self, extract_selector(args).merge(:tag_name => "input"))
+    end
+
+    def text_fields(*args)
+      TextFieldCollection.new(self, extract_selector(args).merge(:tag_name => "input"))
+    end
+  end # Container
+
+  class TextFieldCollection < InputCollection
+    private
+
+    def locator_class
+      TextFieldLocator
+    end
+
+    def element_class
+      TextField
+    end
+  end # TextFieldCollection
+end # WatirNokogiri

data/lib/watir-nokogiri/exception.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+
+module WatirNokogiri
+  module Exception
+    class Error < StandardError; end
+    
+    class UnknownObjectException < Error; end
+    class ObjectDisabledException < Error; end
+    class ObjectReadOnlyException < Error; end
+    class NoValueFoundException < Error; end
+    class MissingWayOfFindingObjectException < Error; end
+    class UnknownCellException < Error; end
+    class NoMatchingWindowFoundException < Error; end
+    class NoStatusBarException < Error; end
+    class NavigationException < Error; end
+    class UnknownFrameException < Error; end
+    class UnknownRowException < Error; end
+  
+  end # Exception
+end # WatirNokogiri

data/lib/watir-nokogiri/locators/button_locator.rb

@@ -0,0 +1,54 @@
+module WatirNokogiri
+  class ButtonLocator < ElementLocator
+
+    def build_nokogiri_selector(selectors)
+      return if selectors.values.any? { |e| e.kind_of? Regexp }
+
+      selectors.delete(:tag_name) || raise("internal error: no tag_name?!")
+
+      @building = :button
+      button_attr_exp = attribute_expression(selectors)
+
+      @building = :input
+      selectors[:type] = Button::VALID_TYPES
+      input_attr_exp = attribute_expression(selectors)
+
+      xpath = ".//button"
+      xpath << "[#{button_attr_exp}]" unless button_attr_exp.empty?
+      xpath << " | .//input"
+      xpath << "[#{input_attr_exp}]"
+
+      p :build_nokogiri_selector => xpath if $DEBUG
+
+      [:xpath, xpath]
+    end
+
+    def lhs_for(key)
+      if @building == :input && key == :text
+        "@value"
+      else
+        super
+      end
+    end
+
+    def equal_pair(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
+
+    def tag_name_matches?(tag_name, _)
+      !!(/^(input|button)$/ === tag_name)
+    end
+
+    def validate_element(element)
+      return if element.node_name.downcase == "input" && !Button::VALID_TYPES.include?(element.get_attribute(:type).downcase)
+      super
+    end
+
+  end # ButtonLocator
+end # WatirNokogiri

data/lib/watir-nokogiri/locators/child_cell_locator.rb

@@ -0,0 +1,24 @@
+module WatirNokogiri
+  class ChildCellLocator < ElementLocator
+
+    private
+    
+    def build_nokogiri_selector(selectors)
+      return if selectors.values.any? { |e| e.kind_of? Regexp }
+
+      expressions = %w[./th ./td]
+      attr_expr = attribute_expression(selectors)
+
+      unless attr_expr.empty?
+        expressions.map! { |e| "#{e}[#{attr_expr}]" }
+      end
+
+      xpath = expressions.join(" | ")
+
+      p :build_nokogiri_selector => xpath if $DEBUG
+
+      [:xpath, xpath]
+    end
+
+  end # ChildCellLocator
+end # WatirNokogiri

data/lib/watir-nokogiri/locators/child_row_locator.rb

@@ -0,0 +1,29 @@
+module WatirNokogiri
+  class ChildRowLocator < ElementLocator
+
+    private
+
+    def build_nokogiri_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?(@nokogiri.node_name.downcase)
+        expressions += %w[./tbody/tr ./thead/tr ./tfoot/tr]
+      end
+
+      attr_expr = attribute_expression(selectors)
+
+      unless attr_expr.empty?
+        expressions.map! { |e| "#{e}[#{attr_expr}]" }
+      end
+
+      xpath = expressions.join(" | ")
+
+      p :build_nokogiri_selector => xpath if $DEBUG
+
+      [:xpath, xpath]
+    end
+
+  end # ChildRowLocator
+end # WatirNokogiri

data/lib/watir-nokogiri/locators/element_locator.rb

@@ -0,0 +1,298 @@
+# encoding: utf-8
+module WatirNokogiri
+  class ElementLocator
+    include WatirNokogiri::Exception
+    
+    def initialize(nokogiri, selector, valid_attributes)
+      @nokogiri = nokogiri
+      @selector = selector.dup
+      @valid_attributes = valid_attributes
+    end
+     
+    def locate()	
+      idx = @selector.delete(:index)
+      if idx
+        element = locate_all[idx]
+      else
+        element = locate_all.first
+      end
+
+      # This actually only applies when finding by xpath - 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)
+      validate_element(element) if element
+    end
+
+    def locate_all()
+      selector = normalized_selector
+
+      if selector.has_key? :index
+        raise ArgumentError, "can't locate all elements by :index"
+      end
+
+      how, what = given_css(selector) ||
+                        given_xpath(selector) || 
+                        build_nokogiri_selector(selector)
+                    
+      case how
+        when :css
+          @nokogiri.css(what)
+        when :xpath
+          @nokogiri.xpath(what)
+        else
+          find_by_regexp_selector(selector, :select)
+      end				
+    end
+        
+    def find_by_regexp_selector(selector, method = :find)
+      parent = @nokogiri
+      rx_selector = delete_regexps_from(selector)
+
+      if rx_selector.has_key?(:label) && should_use_label_element?
+        label = label_from_text(rx_selector.delete(:label)) || (return [])
+        if (id = label.get_attribute('for'))
+          selector[:id] = id
+        else
+          parent = label
+        end
+      end
+
+      how, what = build_nokogiri_selector(selector)
+
+      unless how
+        raise Error, "internal error: unable to build WebDriver selector from #{selector.inspect}"
+      end
+
+      elements = parent.xpath(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.kind_of?(Regexp)
+        rx_selector[how] = what
+        selector.delete how
+      end
+
+      rx_selector
+    end			
+
+    def assert_valid_as_attribute(attribute)     
+      unless valid_attribute? attribute or attribute.to_s =~ /^data_.+$/
+        raise MissingWayOfFindingObjectException, "invalid attribute: #{attribute.inspect}"
+      end
+    end
+
+    def valid_attribute?(attribute)
+      @valid_attributes && @valid_attributes.include?(attribute)
+    end
+
+    def should_use_label_element?
+      @selector[:tag_name] != "option"
+    end
+
+    def label_from_text(label_exp)
+      # TODO: this won't work correctly if @nokogiri is a sub-element
+      @nokogiri.search('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 fetch_value(element, how)
+      case how
+      when :text
+        element.text
+      when :tag_name
+        element.node_name.downcase
+      when :href
+        (href = element.get_attribute('href')) && href.strip
+      else
+        element.get_attribute(how.to_s.gsub("_", "-"))
+      end
+    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 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]
+      when :for
+        assert_valid_as_attribute :html_for
+        [how, what]
+      else
+        assert_valid_as_attribute how
+        [how, what]
+      end
+    end
+
+
+    VALID_WHATS = [String, Regexp]
+
+    def check_type(how, what)
+      case how
+      when :index
+        unless what.kind_of?(Fixnum)
+          raise TypeError, "expected Fixnum, got #{what.inspect}:#{what.class}"
+        end
+      else
+        unless VALID_WHATS.any? { |t| what.kind_of? t }
+          raise TypeError, "expected one of #{VALID_WHATS.inspect}, got #{what.inspect}:#{what.class}"
+        end
+      end
+    end
+      
+    def given_xpath(selector)
+      return unless xpath = selector.delete(:xpath)
+
+      unless selector.empty? || can_be_combined_with_xpath?(selector)
+        raise ArgumentError, ":xpath cannot be combined with other selectors (#{selector.inspect})"
+      end
+
+      [:xpath, xpath]
+    end
+
+    def can_be_combined_with_xpath?(selector)
+      # ouch - is this worth it?
+      keys = selector.keys
+      return true if keys == [:tag_name]
+
+      if selector[:tag_name] == "input"
+        return keys == [:tag_name, :type] || keys == [:type, :tag_name]
+      end
+
+      false
+    end
+    
+    def given_css(selector)  
+      return unless css = selector.delete(:css)
+
+      unless selector.empty? || can_be_combined_with_css?(selector)
+        raise ArgumentError, ":css cannot be combined with other selectors (#{selector.inspect})"
+      end
+
+      [:css, xpath]
+    end
+
+    def can_be_combined_with_css?(selector)
+      # ouch - is this worth it?
+      keys = selector.keys
+      return true if keys == [:tag_name]
+
+      if selector[:tag_name] == "input"
+        return keys == [:tag_name, :type] || keys == [:type, :tag_name]
+      end
+
+      false
+    end   
+
+    def build_nokogiri_selector(selectors)
+      unless selectors.values.any? { |e| e.kind_of? Regexp }
+        build_xpath(selectors)
+      end
+    end
+    
+    def build_xpath(selectors)
+      xpath = ".//"
+      xpath << (selectors.delete(:tag_name) || '*').to_s
+
+      idx = selectors.delete :index
+
+      # the remaining entries should be attributes
+      unless selectors.empty?
+        xpath << "[" << attribute_expression(selectors) << "]"
+      end
+
+      if idx
+        xpath << "[#{idx + 1}]"
+      end
+
+      p :xpath => xpath, :selectors => selectors if $DEBUG
+
+      [:xpath, xpath]
+    end		
+
+    def attribute_expression(selectors)
+      selectors.map do |key, val|
+        if val.kind_of?(Array)
+          "(" + val.map { |v| equal_pair(key, v) }.join(" or ") + ")"
+        else
+          equal_pair(key, val)
+        end
+      end.join(" and ")
+    end
+
+    def equal_pair(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(key)}=#{XpathSupport.escape value}"
+      end
+    end
+
+    def lhs_for(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.gsub("_", "-")}"
+      end
+    end
+
+    def validate_element(element)
+      tn = @selector[:tag_name]
+      element_tag_name = element.node_name.downcase
+
+      return if tn && !tag_name_matches?(element_tag_name, tn)
+
+      if element_tag_name == 'input'
+        return if @selector[:type] && @selector[:type] != element.get_attribute(:type).downcase
+      end
+
+      element
+    end
+    
+    def tag_name_matches?(element_tag_name, tag_name)
+      tag_name === element_tag_name
+    end    
+
+  end # ElementLocator
+end # WatirNokogiri