watir-webdriver 0.0.9 → 0.1.0

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

@@ -1,36 +1,45 @@
 module Watir
   class TableRow < HTMLElement
+    include CellContainer
+
+    # @private
+    attr_writer :locator_class
 
     #
-    # Get the n'th <td> of this element
+    # Get the n'th cell (<th> or <td>) of this row
     #
-    # @return Watir::TableDataCell
+    # @return Watir::TableCell
     #
 
     def [](idx)
-      td(:index, idx)
+      cell(:index, idx)
     end
 
     private
 
-    def locate
-      if @parent.kind_of?(Watir::Table)
-        @parent.assert_exists
-        TableRowLocator.new(@parent.wd, @selector, self.class.attribute_list).locate
-      else
-        super
-      end
+    def locator_class
+      @locator_class || super
     end
-
   end # TableRow
 
 
   class TableRowCollection < ElementCollection
-    private
+    attr_writer :locator_class
 
-    def locator_class
-      @parent.kind_of?(Watir::Table) ? TableRowLocator : super
+    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/table_section.rb

@@ -0,0 +1,9 @@
+module Watir
+  class TableSection < HTMLElement
+    include RowContainer
+
+    def [](idx)
+      row(:index => idx)
+    end
+  end
+end

data/lib/watir-webdriver/extensions/alerts.rb

@@ -0,0 +1,69 @@
+module Watir
+
+  #
+  # Module provided by optional require:
+  #
+  #   require "watir-webdriver/extensions/alerts"
+  #
+
+  module AlertHelper
+
+    #
+    # Overwrite window.alert()
+    #
+    # This method is provided by an optional require - API is subject to change.
+    #
+    # @example
+    #   browser.alert do
+    #     browser.button(:value => "Alert").click
+    #   end #=> "the alert message"
+    #
+
+    def alert(&blk)
+      execute_script "window.alert = function(msg) { window.__lastWatirAlert = msg; }"
+      yield
+      execute_script "return window.__lastWatirAlert"
+    end
+
+    #
+    # Overwrite window.confirm()
+    #
+    # This method is provided by an optional require - API is subject to change.
+    #
+    # @example
+    #   browser.confirm(true) do
+    #     browser.button(:value => "Confirm").click
+    #   end #=> "the confirm message"
+
+    def confirm(bool, &blk)
+      execute_script "window.confirm = function(msg) { window.__lastWatirConfirm = msg; return #{!!bool} }"
+      yield
+      execute_script "return window.__lastWatirConfirm"
+    end
+
+    #
+    # Overwrite window.prompt()
+    #
+    # This method is provided by an optional require - API is subject to change.
+    #
+    # @example
+    #   browser.prompt("hello") do
+    #     browser.button(:value => "Prompt").click
+    #   end #=> { :message => "foo", :default => "bar" }
+    #
+
+    def prompt(answer, &blk)
+      execute_script "window.prompt = function(text, value) { window.__lastWatirPrompt = { message: text, default: value }; return #{answer.to_json}; }"
+      yield
+      result = execute_script "return window.__lastWatirPrompt"
+
+      result && result.dup.each_key { |k| result[k.to_sym] = result.delete(k)}
+      result
+    end
+  end
+
+  class Browser
+    include AlertHelper
+  end
+
+end

data/lib/watir-webdriver/extensions/performance.rb

@@ -0,0 +1,54 @@
+require "ostruct"
+
+module Watir
+
+  # Adds helper for window.performance to Watir::Browser.
+  #
+  # This module is provided by an optional require:
+  #
+  #   require "watir-webdriver/extensions/performance"
+  #
+  # @see http://dev.w3.org/2006/webapi/WebTiming/
+  #
+
+  module PerformanceHelper
+
+    def performance
+      data = driver.execute_script("return window.performance || window.webkitPerformance || window.mozPerformance || window.msPerformance;")
+      data && Performance.new(data)
+    end
+
+    class Performance
+      attr_reader :timing, :navigation, :memory
+
+      def initialize(data)
+        @timing     = rubify data['timing'] || {}
+        @navigation = rubify data['navigation'] || {}
+        @memory     = rubify data['memory'] || {}
+      end
+
+      private
+
+      def rubify(hash)
+        result = {}
+
+        hash.each do |k, v|
+          if k =~ /^[A-Z_]+$/
+            k = k.downcase
+          elsif k =~ /(start|end)$/i && Fixnum === v
+            v = ::Time.at(v / 1000)
+          end
+
+          result[k.snake_case] = v
+        end
+
+        OpenStruct.new(result)
+      end
+
+    end # Performance
+  end # PerformanceHelper
+
+  class Browser
+    include PerformanceHelper
+  end
+end # Watir

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

@@ -1,8 +1,6 @@
 module Watir
   class ButtonLocator < ElementLocator
 
-    VALID_TYPES = %w[button reset submit image]
-
     def locate_all
       find_all_by_multiple
     end
@@ -12,7 +10,7 @@ module Watir
     def wd_find_first_by(how, what)
       if how == :tag_name
         how  = :xpath
-        what = ".//button | .//input[#{attribute_expression :type => VALID_TYPES}]"
+        what = ".//button | .//input[#{attribute_expression :type => Button::VALID_TYPES}]"
       end
 
       super
@@ -27,7 +25,7 @@ module Watir
       button_attr_exp = attribute_expression(selectors)
 
       @building = :input
-      selectors[:type] = VALID_TYPES
+      selectors[:type] = Button::VALID_TYPES
       input_attr_exp = attribute_expression(selectors)
 
       xpath = ".//button"
@@ -68,7 +66,7 @@ module Watir
     end
 
     def validate_element(element)
-      return if element.tag_name == "input" && !VALID_TYPES.include?(element.attribute(:type))
+      return if element.tag_name == "input" && !Button::VALID_TYPES.include?(element.attribute(:type))
       super
     end
 

data/lib/watir-webdriver/locators/{table_row_locator.rb → child_cell_locator.rb}

@@ -1,5 +1,5 @@
 module Watir
-  class TableRowLocator < ElementLocator
+  class ChildCellLocator < ElementLocator
 
     def locate_all
       find_all_by_multiple
@@ -7,21 +7,26 @@ module Watir
 
     private
 
+    def by_id
+      nil
+    end
+
     def build_xpath(selectors)
       return if selectors.values.any? { |e| e.kind_of? Regexp }
 
-      selectors.delete(:tag_name) || raise("internal error: no tag_name?!")
-
+      expressions = %w[./th ./td]
       attr_expr = attribute_expression(selectors)
 
+      unless attr_expr.empty?
+        expressions.map! { |e| "#{e}[#{attr_expr}]" }
+      end
 
-      xpath = "./*/child::tr"
-      xpath << "[#{attr_expr}]" unless attr_expr.empty?
+      xpath = expressions.join(" | ")
 
       p :build_xpath => xpath if $DEBUG
 
       xpath
     end
 
-  end # TableRowLocator
+  end # ChildCellLocator
 end # Watir

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

@@ -0,0 +1,37 @@
+module Watir
+  class ChildRowLocator < ElementLocator
+
+    def locate_all
+      find_all_by_multiple
+    end
+
+    private
+
+    def by_id
+      nil # avoid this
+    end
+
+    def build_xpath(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?(@wd.tag_name)
+        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_xpath => xpath if $DEBUG
+
+      xpath
+    end
+
+  end # ChildRowLocator
+end # Watir

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

@@ -24,10 +24,8 @@ module Watir
     end
 
     def locate
-      # short-circuit if :id is given
-      if e = by_id
-        return e
-      end
+      e = by_id and return e # short-circuit if :id is given
+
 
       if @selector.size == 1
         element = find_first_by_one
@@ -78,7 +76,7 @@ module Watir
       selector = normalized_selector
 
       idx   = selector.delete(:index)
-      xpath = selector[:xpath] || build_xpath(selector)
+      xpath = given_xpath(selector) || build_xpath(selector)
 
       if xpath
         # could build xpath for selector
@@ -104,7 +102,7 @@ module Watir
         raise ArgumentError, "can't locate all elements by :index"
       end
 
-      xpath = selector[:xpath] || build_xpath(selector)
+      xpath = given_xpath(selector) || build_xpath(selector)
       if xpath
         @wd.find_elements(:xpath, xpath)
       else
@@ -199,13 +197,14 @@ module Watir
 
     def normalize_selector(how, what)
       case how
-      when :caption
-        [:text, what]
+      when :tag_name, :text, :xpath, :index, :class, :for
+        # 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 :tag_name, :text, :xpath, :index, :class
-        # include class since the valid attribute is 'class_name'
-        [how, what]
+      when :caption
+        [:text, what]
       else
         assert_valid_as_attribute how
         [how, what]
@@ -231,14 +230,15 @@ module Watir
     end
 
     def by_id
+      return unless id = @selector[:id] and id.kind_of? String
+
       selector = @selector.dup
-      id       = selector.delete(:id)
-      return unless id && id.kind_of?(String)
+      selector.delete(:id)
 
       tag_name = selector.delete(:tag_name)
       return unless selector.empty? # multiple attributes
 
-      element  = @wd.find_element(:id, id)
+      element = @wd.find_element(:id, id)
       return if tag_name && !tag_name_matches?(element, tag_name)
 
       element
@@ -326,5 +326,15 @@ module Watir
       element
     end
 
+    def given_xpath(selector)
+      return unless xpath = selector.delete(:xpath)
+
+      unless selector.empty? || selector.keys == [:tag_name] || (selector[:tag_name] == "input" && selector.keys == [:tag_name, :type])
+        raise ArgumentError, ":xpath cannot be combined with other selectors (#{selector.inspect})"
+      end
+
+      xpath
+    end
+
   end # ElementLocator
 end # Watir

data/lib/watir-webdriver/row_container.rb

@@ -0,0 +1,19 @@
+module Watir
+  module RowContainer
+
+    def row(*args)
+      row = tr(*args)
+      row.locator_class = ChildRowLocator
+
+      row
+    end
+
+    def rows(*args)
+      rows = trs(*args)
+      rows.locator_class = ChildRowLocator
+
+      rows
+    end
+
+  end
+end

data/lib/watir-webdriver/window_switching.rb

@@ -1,15 +1,16 @@
 module Watir
   module WindowSwitching
 
+    class NoMatchingWindowFoundException < StandardError
+    end
+
     def windows(*args)
-      wins = @driver.window_handles.map do |id|
-        Window.new(@driver, id)
-      end
+      all = @driver.window_handles.map { |id| Window.new(@driver, id) }
 
       if args.empty?
-        wins
+        all
       else
-        filter_windows(args, wins, :select)
+        filter_windows(args, all, :select)
       end
     end
 
@@ -20,19 +21,23 @@ module Watir
         win.use(&blk)
       end
 
-      win
+      win or raise NoMatchingWindowFoundException, args.inspect
     end
 
     private
 
-    def filter_windows(args, wins, method)
+    def filter_windows(args, all, method)
       sel = extract_selector(args)
 
+      if sel.empty?
+        all.find { |w| w.current? }
+      end
+
       unless sel.keys.all? { |k| [:title, :url].include? k }
-        raise ArgumentError, "invalid window selector: #{sel}"
+        raise ArgumentError, "invalid window selector: #{sel.inspect}"
       end
 
-      wins.send(method) do |win|
+      all.send(method) do |win|
         sel.all? { |key, value| value === win.send(key) }
       end
     end
@@ -43,11 +48,21 @@ module Watir
       @driver, @id = driver, id
     end
 
-
     def inspect
       '#<%s:0x%x id=%s>' % [self.class, hash*2, @id.to_s]
     end
 
+    def ==(other)
+      return false unless other.kind_of?(self.class)
+
+      @id == other.id
+    end
+    alias_method :eql?, :==
+
+    def hash
+      @id.hash ^ self.class.hash
+    end
+
     def current?
       @driver.window_handle == @id
     end
@@ -71,8 +86,20 @@ module Watir
     end
 
     def use(&blk)
+      if current?
+        yield if block_given?
+        return self
+      end
+
       @driver.switch_to.window(@id, &blk)
       self
     end
+
+    protected
+
+    def id
+      @id
+    end
+
   end # Window
 end # Watir