watir-webdriver 0.0.7 → 0.0.8

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

@@ -42,4 +42,10 @@ module Watir
     end
 
   end # Image
+
+  module Container
+     alias_method :image, :img
+     alias_method :images, :imgs
+  end # Container
+
 end # Watir

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

@@ -1,9 +1,5 @@
 # encoding: utf-8
 module Watir
-  class Anchor
-    alias_method :url, :href # deprecate?
-  end # Anchor
-
   module Container
     alias_method :link,  :a
     alias_method :links, :as

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

@@ -56,7 +56,7 @@ module Watir
     #
 
     def select(str_or_rx)
-      select_by :text, str_or_rx, multiple?
+      select_by :text, str_or_rx
     end
 
     #
@@ -70,7 +70,7 @@ module Watir
     #
 
     def select_value(str_or_rx)
-      select_by :value, str_or_rx, multiple?
+      select_by :value, str_or_rx
     end
 
     #
@@ -116,25 +116,25 @@ module Watir
 
     private
 
-    def select_by(how, str_or_rx, multiple)
+    def select_by(how, str_or_rx)
+      assert_exists
+
       case str_or_rx
       when String, Numeric
-        select_by_string(how, str_or_rx.to_s, multiple)
+        select_by_string(how, str_or_rx.to_s)
       when Regexp
-        select_by_regexp(how, str_or_rx, multiple)
+        select_by_regexp(how, str_or_rx)
       else
-        raise ArgumentError, "expected String or Regexp, got #{str_or_rx.inspect}:#{str_or_rx.class}"
+        raise TypeError, "expected String or Regexp, got #{str_or_rx.inspect}:#{str_or_rx.class}"
       end
     end
 
-    def select_by_string(how, string, multiple)
+    def select_by_string(how, string)
       xpath = option_xpath_for(how, string)
-      if multiple
-        elements = @element.find_elements(:xpath, xpath)
 
-        if elements.empty?
-          raise NoValueFoundException, "#{string.inspect} not found in select list"
-        end
+      if multiple?
+        elements = @element.find_elements(:xpath, xpath)
+        no_value_found(string) if elements.empty?
 
         elements.each { |e| e.select unless e.selected? }
         elements.first.text
@@ -142,7 +142,7 @@ module Watir
         begin
           e = @element.find_element(:xpath, xpath)
         rescue WebDriver::Error::NoSuchElementError
-          raise NoValueFoundException, "#{string.inspect} not found in select list"
+          no_value_found(string)
         end
 
         e.select unless e.selected?
@@ -151,29 +151,23 @@ module Watir
       end
     end
 
-    def select_by_regexp(how, exp, multiple)
+    def select_by_regexp(how, exp)
       elements = @element.find_elements(:tag_name, 'option')
-      if elements.empty?
-        raise NoValueFoundException, "no options in select list"
-      end
+      no_value_found(nil, "no options in select list") if elements.empty?
 
-      if multiple
+      if multiple?
         found = elements.select do |e|
           next unless matches_regexp?(how, e, exp)
           e.select unless e.selected?
           true
         end
 
-        if found.empty?
-          raise NoValueFoundException, "#{exp.inspect} not found in select list"
-        end
+        no_value_found(exp) if found.empty?
 
         found.first.text
       else
         element = elements.find { |e| matches_regexp?(how, e, exp) }
-        unless element
-          raise NoValueFoundException, "#{exp.inspect} not found in select list"
-        end
+        no_value_found(exp) unless element
 
         element.select unless element.selected?
 
@@ -210,6 +204,10 @@ module Watir
 
       ''
     end
+
+    def no_value_found(arg, msg = nil)
+      raise NoValueFoundException, msg || "#{arg.inspect} not found in select list"
+    end
   end # Select
 
   module Container

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

@@ -23,4 +23,14 @@ module Watir
     end
 
   end # TableRow
-end # Watir
+
+
+  class TableRowCollection < ElementCollection
+    private
+
+    def locator_class
+      @parent.kind_of?(Watir::Table) ? TableRowLocator : super
+    end
+
+  end # TableRowCollection
+end # Watir

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

@@ -3,6 +3,7 @@ module Watir
   class TextField < Input
 
     attributes Watir::TextArea.typed_attributes
+    remove_method :type # we want Input#type here, which was overriden by TextArea's attributes
 
     def self.from(parent, element)
       type = element.attribute(:type)
@@ -14,14 +15,6 @@ module Watir
       super
     end
 
-    # hacky, but we want Input#type here, which was overriden by TextArea's attributes
-    # so we're *overwriting* that method definition here
-    def type; super; end
-
-    def inspect
-      '#<%s:0x%x located=%s selector=%s>' % [self.class, hash*2, !!@element, selector_string]
-    end
-
     #
     # Clear the element, the type in the given value.
     #
@@ -73,13 +66,10 @@ module Watir
     end
 
     def selector_string
-      selector_without_type.inspect
-    end
-
-    def selector_without_type
-      s = @selector.dup
-      s[:type] = '(any text type)'
-      s
+      selector = @selector.dup
+      selector[:type] = '(any text type)'
+      selector[:tag_name] = "input or textarea"
+      selector.inspect
     end
   end
 

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

@@ -0,0 +1,107 @@
+# encoding: utf-8
+module Watir
+  module Wait
+    module_function
+
+    class TimeoutError < StandardError
+    end
+
+    #
+    # Wait until the block evaluates to true or times out.
+    #
+
+    def until(timeout = 30, &block)
+      end_time = ::Time.now + timeout
+
+      until ::Time.now > end_time
+        result = yield(self)
+        return result if result
+        sleep 0.5
+      end
+
+      raise TimeoutError, "timed out after #{timeout} seconds"
+    end
+
+    #
+    # Wait while the block evaluates to true or times out.
+    #
+
+    def while(timeout = 30, &block)
+      end_time = ::Time.now + timeout
+
+      until ::Time.now > end_time
+        return unless yield(self)
+        sleep 0.5
+      end
+
+      raise TimeoutError, "timed out after #{timeout} seconds"
+    end
+
+  end # Wait
+
+  #
+  # Wraps an Element so that any subsequent method calls are
+  # put on hold until the element is present (exists and is visible) on the page.
+  #
+
+  class WhenPresentDecorator
+    def initialize(element, timeout)
+      @element = element
+      @timeout = timeout
+    end
+
+    def method_missing(m, *args, &block)
+      unless @element.respond_to?(m)
+        raise NoMethodError, "undefined method `#{m}' for #{@element.inspect}:#{@element.class}"
+      end
+
+      Watir::Wait.until(@timeout) { @element.present? }
+      
+      @element.__send__(m, *args, &block)
+    end
+  end # WhenPresentDecorator
+
+  class Element
+
+    #
+    # Returns true if the element exists and is visible on the page
+    #
+
+    def present?
+      exists? && visible?
+    end
+
+    #
+    # Waits until the element is present.
+    #
+    # Optional argument:
+    #
+    #   timeout   -  seconds to wait before timing out (default: 30)
+    #
+    #     browser.button(:id, 'foo').when_present.click
+    #     browser.div(:id, 'bar').when_present { |div| ... }
+    #     browser.p(:id, 'baz').when_present(60).text
+    #
+
+    def when_present(timeout = 30)
+      if block_given?
+        Watir::Wait.until(timeout) { self.present? }
+        yield self
+      else
+        WhenPresentDecorator.new(self, timeout)
+      end
+    end
+
+    def wait_until_present(timeout = 30)
+      Watir::Wait.until(timeout) { self.present? }
+    end
+
+    def wait_while_present(timeout = 30)
+      Watir::Wait.while(timeout) { self.present? }
+    rescue Selenium::WebDriver::Error::ObsoleteElementError
+      # it's not present
+    end
+  end # Element
+
+
+end # Watir

data/lib/watir-webdriver/html/generator.rb

@@ -104,7 +104,7 @@ CODE
 
       def indent(code, indent = 1)
         indent_string = " "*indent
-        code.split("\n").map { |line| indent_string + line }.join("\n")
+        code.split("\n").map { |line| line.empty? ? line : indent_string + line }.join("\n")
       end
 
     end # Generator

data/lib/watir-webdriver/html/util.rb

@@ -4,7 +4,6 @@ module Watir
 
       module_function
 
-
       def classify(name)
         if name =~ /^HTML(.+)Element$/
           $1
@@ -13,16 +12,8 @@ module Watir
         end
       end
 
-      SPECIALS = {
-        'img' => 'image'
-      }
-
       def paramify(str)
-        if SPECIALS.has_key?(str)
-          SPECIALS[str]
-        else
-          classify(str).snake_case
-        end
+        classify(str).snake_case
       end
 
     end # Util

data/lib/watir-webdriver/html/visitor.rb

@@ -111,22 +111,10 @@ module Watir
 
         attrs = Hash.new { |hash, key| hash[key] = [] }
         attributes.each do |a|
-          attrs[ruby_type_for(a.type)] << a.name.snake_case
+          attrs[ruby_type_for(a.type)] << a.name.snake_case.to_sym
         end
 
-        call :attributes, [[:hash] + attrs.map { |type, names| [[:lit, type], literal_array(names)] }.flatten(1)]
-      end
-
-      def identifier_call(tag_name)
-        call :identifier, [literal_hash(:tag_name => tag_name)]
-      end
-
-      def container_call(name)
-        call :container_method,  [[:lit, Util.paramify(name).to_sym]]
-      end
-
-      def collection_call(name)
-        call :collection_method, [[:lit, Util.paramify(name).pluralize.to_sym]]
+        call :attributes, [literal_hash(attrs)]
       end
 
       def literal_hash(hash)

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

@@ -1,10 +1,23 @@
 module Watir
   class ButtonLocator < ElementLocator
 
+    VALID_TYPES = %w[button reset submit image]
+
     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[#{attribute_expression :type => VALID_TYPES}]"
+      end
+
+      super
+    end
+
     def build_xpath(selectors)
       return if selectors.values.any? { |e| e.kind_of? Regexp }
 
@@ -14,7 +27,7 @@ module Watir
       button_attr_exp = attribute_expression(selectors)
 
       @building = :input
-      selectors[:type] = %w[button reset submit image]
+      selectors[:type] = VALID_TYPES
       input_attr_exp = attribute_expression(selectors)
 
       xpath = ".//button"
@@ -37,7 +50,7 @@ module Watir
       end
     end
 
-    def matches_selector?(rx_selector, element)
+    def matches_selector?(element, rx_selector)
       rx_selector = rx_selector.dup
 
       [:value, :caption].each do |key|
@@ -53,5 +66,11 @@ module Watir
     def tag_name_matches?(element, _)
       !!(/^(input|button)$/ === element.tag_name)
     end
+
+    def validate_element(element)
+      return if element.tag_name == "input" && !VALID_TYPES.include?(element.attribute(:type))
+      super
+    end
+
   end # ButtonLocator
-end # Watir
+end # Watir

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

@@ -30,10 +30,14 @@ module Watir
       end
 
       if @selector.size == 1
-        find_first_by_one
+        element = find_first_by_one
       else
-        find_first_by_multiple
+        element = find_first_by_multiple
       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.
+      validate_element(element) if element
     rescue WebDriver::Error::NoSuchElementError => wde
       nil
     end
@@ -46,25 +50,27 @@ module Watir
       end
     end
 
+    private
+
     def find_first_by_one
-      how, what = @selector.shift
+      how, what = @selector.to_a.first
       check_type how, what
 
       if WD_FINDERS.include?(how)
         wd_find_first_by(how, what)
       else
-        raise NotImplementedError, "find first by attribute/other"
+        find_first_by_multiple
       end
     end
 
     def find_all_by_one
-      how, what = @selector.shift
+      how, what = @selector.to_a.first
       check_type how, what
 
       if WD_FINDERS.include?(how)
         wd_find_all_by(how, what)
       else
-        raise NotImplementedError, "find all by attribute/other"
+        find_all_by_multiple
       end
     end
 
@@ -95,7 +101,7 @@ module Watir
       selector = normalized_selector
 
       if selector.has_key? :index
-        raise Error, "can't locate all elements by :index"
+        raise ArgumentError, "can't locate all elements by :index"
       end
 
       xpath = selector[:xpath] || build_xpath(selector)
@@ -110,7 +116,7 @@ module Watir
       if what.kind_of? String
         @wd.find_element(how, what)
       else
-        all_elements.find { |e| fetch_value(how, e) =~ what }
+        all_elements.find { |element| fetch_value(element, how) =~ what }
       end
     end
 
@@ -118,7 +124,7 @@ module Watir
       if what.kind_of? String
         @wd.find_elements(how, what)
       else
-        all_elements.select { |e| fetch_value(how, e) =~ what }
+        all_elements.select { |element| fetch_value(element, how) =~ what }
       end
     end
 
@@ -126,45 +132,55 @@ module Watir
       rx_selector = delete_regexps_from(selector)
 
       if rx_selector.has_key?(:label) && should_use_label_element?
-        label_exp = rx_selector.delete(:label)
-        label     = @wd.find_elements(:tag_name, 'label').find { |e| matches_selector?({:text => label_exp}, e) } || return
-
-        selector[:id] = label.attribute(:for)
+        selector[:id] = id_from_label(rx_selector.delete(:label)) || return
       end
 
-      xpath = build_xpath(selector) || raise("internal error: unable to build xpath from #{@selector.inspect}")
+      xpath = build_xpath(selector) || raise("internal error: unable to build xpath from #{selector.inspect}")
 
       elements = @wd.find_elements(:xpath, xpath)
-      elements.send(method) { |e| matches_selector?(rx_selector, e) }
+      elements.__send__(method) { |el| matches_selector?(el, rx_selector) }
     end
 
+    VALID_WHATS = [String, Regexp]
+
     def check_type(how, what)
       case how
       when :index
-        raise TypeError, "expected Fixnum, got #{what.class}" unless what.kind_of?(Fixnum)
+        unless what.kind_of?(Fixnum)
+          raise TypeError, "expected Fixnum, got #{what.inspect}:#{what.class}"
+        end
       else
-        unless [String, Regexp].any? { |t| what.kind_of? t }
-          raise TypeError, "expected String or Regexp, got #{what.inspect}:#{what.class}"
+        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 fetch_value(how, element)
+    def id_from_label(label_exp)
+      # TODO: this won't work correctly if @wd is a sub-element
+      label = @wd.find_elements(:tag_name, 'label').find do |el|
+        matches_selector?(el, :text => label_exp)
+      end
+
+      label.attribute(:for) if label
+    end
+
+    def fetch_value(element, how)
       case how
       when :text
         element.text
       when :tag_name
         element.tag_name
+      when :href
+        (href = element.attribute(:href)) && href.strip
       else
         element.attribute(how)
       end
     end
 
-    def matches_selector?(selector, element)
-      # p :start => selector
+    def matches_selector?(element, selector)
       selector.all? do |how, what|
-        # p :comparing => [how, what], :to => fetch_value(how, element)
-        what === fetch_value(how, element)
+        what === fetch_value(element, how)
       end
     end
 
@@ -183,13 +199,12 @@ module Watir
 
     def normalize_selector(how, what)
       case how
-      when :url
-        [:href, what]
       when :caption
         [:text, what]
       when :class_name
         [:class, what]
-      when :tag_name, :text, :xpath, :index, :class # include class since the attribute method is 'class_name'
+      when :tag_name, :text, :xpath, :index, :class
+        # include class since the valid attribute is 'class_name'
         [how, what]
       else
         assert_valid_as_attribute how
@@ -210,7 +225,7 @@ module Watir
     end
 
     def assert_valid_as_attribute(attribute)
-      unless valid_attribute? attribute
+      unless valid_attribute? attribute or attribute.to_s =~ /^data_.+$/
         raise MissingWayOfFindingObjectException, "invalid attribute: #{attribute.inspect}"
       end
     end
@@ -272,7 +287,7 @@ module Watir
     def attribute_expression(selectors)
       selectors.map do |key, val|
         if val.kind_of?(Array)
-          "( " + val.map { |v| equal_pair(key, v) }.join(" or ") + " )"
+          "(" + val.map { |v| equal_pair(key, v) }.join(" or ") + ")"
         else
           equal_pair(key, val)
         end
@@ -300,5 +315,16 @@ module Watir
       end
     end
 
+    def validate_element(element)
+      tn = @selector[:tag_name]
+      return if tn && !tag_name_matches?(element, tn)
+
+      if element.tag_name == 'input'
+        return if @selector[:type] && @selector[:type] != element.attribute(:type)
+      end
+
+      element
+    end
+
   end # ElementLocator
 end # Watir