watir 2.0.4 → 3.0.0.rc1

data/lib/watir/image.rb

@@ -42,22 +42,22 @@ module Watir
       return @o.invoke("fileCreatedDate")
     end
     
-    # this method returns the filesize of the image
+    # this method returns the filesize of the image, as an int
     def file_size
       assert_exists
-      return @o.invoke("fileSize").to_s
+      return @o.invoke("fileSize").to_i
     end
     
-    # returns the width in pixels of the image, as a string
+    # returns the width in pixels of the image, as an int
     def width
       assert_exists
-      return @o.invoke("width").to_s
+      return @o.invoke("width").to_i
     end
     
-    # returns the height in pixels of the image, as a string
+    # returns the height in pixels of the image, as an int
     def height
       assert_exists
-      return @o.invoke("height").to_s
+      return @o.invoke("height").to_i
     end
     
     # This method attempts to find out if the image was actually loaded by the web browser.
@@ -103,22 +103,19 @@ module Watir
     def save(path)
       @container.goto(src)
       begin
-        thrd = fill_save_image_dialog(path)
+        fill_save_image_dialog(path)
         @container.document.execCommand("SaveAs")
-        thrd.join(5)
       ensure
         @container.back
       end
     end
     
     def fill_save_image_dialog(path)
-      command = "require 'rautomation';" <<
+      command = "require 'rubygems';require 'rautomation';" <<
                 "window=::RAutomation::Window.new(:title => 'Save Picture');" <<
-                "window.text_field(:class => 'Edit', :index => 0).set('#{path}');" <<
+                "window.text_field(:class => 'Edit', :index => 0).set('#{path.gsub(File::SEPARATOR, File::ALT_SEPARATOR)}');" <<
                 "window.button(:value => '&Save').click"
-      Thread.new do
-        system("ruby -e \"#{command}\"")
-      end
+      IO.popen("ruby -e \"#{command}\"")
     end
     private :fill_save_image_dialog
 

data/lib/watir/input_elements.rb

@@ -2,9 +2,9 @@ module Watir
   
   class InputElement < Element #:nodoc:all
     def locate
-      locator_or_element = @container.input_element_locator(@how, @what, self.class::INPUT_TYPES, self.class)
-      @o = locator_or_element.is_a?(WIN32OLE) ? locator_or_element : locator_or_element.locate
+      @o = @container.locator_for(InputElementLocator, self.class::INPUT_TYPES, @how, @what, self.class).locate
     end
+
     def initialize(container, how, what)
       set_container container
       @how = how
@@ -22,199 +22,120 @@ module Watir
   class SelectList < InputElement
     #:stopdoc:
     INPUT_TYPES = ["select-one", "select-multiple"]
-    #exposed to Option class
-    attr_accessor :o
     #:startdoc:
 
+    def_wrap :multiple?, :multiple
+
     # This method clears the selected items in the select box
     def clear
-      assert_exists
-      highlight(:set)
-      wait = false
-      @o.each do |selectBoxItem|
-        if selectBoxItem.selected
-          selectBoxItem.selected = false
-          wait = true
-        end
+      perform_action do
+        options.each {|option| option.clear}
       end
-      @container.wait if wait
-      highlight(:clear)
     end
 
-
     # This method selects an item, or items in a select box, by text.
     # Raises NoValueFoundException   if the specified value is not found.
     #  * item   - the thing to select, string or reg exp
     def select(item)
-      select_item_in_select_list(:text, item)
+      matching_options = []
+      perform_action do
+        matching_options = matching_items_in_select_list(:text, item) + 
+          matching_items_in_select_list(:label, item) + 
+          matching_items_in_select_list(:value, item)
+        raise NoValueFoundException, "No option with :text, :label or :value of #{item.inspect} in this select element" if matching_options.empty?
+        matching_options.each(&:select)
+      end
+      matching_options.first.text
     end
-    alias :set :select
        
     # Selects an item, or items in a select box, by value.
-    # Raises NoValueFoundException   if the specified value is not found.
-    #  * item   - the value of the thing to select, string, reg exp
+    # Raises NoValueFoundException if the specified value is not found.
+    #  * item   - the value of the thing to select, string or reg exp
     def select_value(item)
-      select_item_in_select_list(:value, item)
-    end
-    
-    # BUG: Should be private
-    # Selects something from the select box
-    #  * name  - symbol  :value or :text - how we find an item in the select box
-    #  * item  - string or reg exp - what we are looking for
-    def select_item_in_select_list(attribute, value) #:nodoc:
-      assert_exists
-      highlight(:set)
-      found = false
-
-      value = value.to_s unless [Regexp, String].any? { |e| value.kind_of? e }
-
-      @container.log "Setting box #{@o.name} to #{attribute.inspect} => #{value.inspect}"
-      @o.each do |option| # items in the list
-        if value.matches(option.invoke(attribute.to_s))
-          if option.selected
-            found = true
-            break
-          else
-            option.selected = true
-            dispatch_event("onChange")
-            @container.wait
-            found = true
-            break
-          end
-        end
-      end
-
-      unless found
-        raise NoValueFoundException, "No option with #{attribute.inspect} of #{value.inspect} in this select element"
-      end
-      highlight(:clear)
-    end
-
-    # Returns array of all text items displayed in a select box
-    # An empty array is returned if the select box has no contents.
-    # Raises UnknownObjectException if the select box is not found
-    def options 
-      assert_exists
-      @container.log "There are #{@o.length} items"
-      returnArray = []
-      @o.each { |thisItem| returnArray << thisItem.text }
-      return returnArray
+      matching_options = matching_items_in_select_list(:value, item)
+      raise NoValueFoundException, "No option with :value of #{item.inspect} in this select element" if matching_options.empty?
+      matching_options.each(&:select)
+      matching_options.first.value
     end
     
     # Returns array of the selected text items in a select box
     # Raises UnknownObjectException if the select box is not found.
     def selected_options
-      assert_exists
-      returnArray = []
-      @container.log "There are #{@o.length} items"
-      @o.each do |thisItem|
-        if thisItem.selected
-          @container.log "Item (#{thisItem.text}) is selected"
-          returnArray << thisItem.text
-        end
-      end
-      return returnArray
+      options.select(&:selected?)
     end
 
     # Does the SelectList include the specified option (text)?
     def include? text_or_regexp
-      getAllContents.grep(text_or_regexp).size > 0
+      !options.map(&:text).grep(text_or_regexp).empty?
     end
 
     # Is the specified option (text) selected? Raises exception of option does not exist.
     def selected? text_or_regexp
-      unless includes? text_or_regexp
-        raise UnknownObjectException, "Option #{text_or_regexp.inspect} not found."
-      end
-
-      getSelectedItems.grep(text_or_regexp).size > 0
-    end
-
-    # this method provides the access to the <tt><option></tt> item in select_list
-    #
-    # Usage example:
-    #
-    # Given the following html:
-    #
-    #   <select  id="gender">
-    #     <option value="U">Unknown</option>
-    #     <option value="M" selected>Male</option>
-    #     <option value="F">Female</option>
-    #   </select>
-    #
-    # get the +value+ attribute of option with visible +text+ 'Female'
-    #   browser.select_list(:id, 'gender').option(:text, 'Female').value #=> 'F'
-    # or find out if the +value+ 'M' is selected
-    #   browser.select_list(:id, 'gender').option(:value, 'M').selected #=> true
-    #
-    #  * attribute  - Symbol :value, :text or other attribute - how we find an item in the select box
-    #  * value  - string or reg exp - what we are looking for
-    def option(attribute, value)
-      assert_exists
-      Option.new(self, attribute, value)
+      raise UnknownObjectException, "Option #{text_or_regexp.inspect} not found." unless include? text_or_regexp
+      !selected_options.map(&:text).grep(text_or_regexp).empty?
     end
-  end
-  
-  module OptionAccess
-    # text of SelectList#option
-    def text
-      @option.text
-    end
-    # value of SelectList#option
-    def value
-      @option.value
-    end
-    # return true if SelectList#option is selected, else false
-    def selected
-      @option.selected
-    end
-  end
-  
-  class OptionWrapper #:nodoc:all
-    include OptionAccess
-    def initialize(option)
-      @option = option
+
+    private
+
+    def matching_items_in_select_list(attribute, value)
+      options.select do |opt|
+        if value.is_a?(Regexp)
+          opt.send(attribute) =~ value
+        elsif value.is_a?(String) || value.is_a?(Numeric)
+          opt.send(attribute) == value
+        else
+          raise TypeError, "#{value.inspect} can be only String, Regexp or Numeric!"
+        end
+      end
     end
   end
   
-  # An item in a select list.
-  # Normally a user would not need to create this object as it is returned by the Watir::SelectList#option method
-  class Option
-    include OptionAccess
-    include Watir::Exception
-    def initialize(select_list, attribute, value)
-      @select_list = select_list
-      @how = attribute
-      @what = value
-      @option = nil
-      
-      unless [:text, :value, :label].include? attribute
-        raise MissingWayOfFindingObjectException,
-                    "Option does not support attribute #{@how}"
-      end
-      @select_list.o.each do |option| # items in the list
-        if value.matches(option.invoke(attribute.to_s))
-          @option = option
-          break
+  class Option < NonControlElement
+
+    def select
+      perform_action do
+        unless selected?
+          ole_object.selected = true
+          select_list.dispatch_event("onChange")
+          @container.wait
         end
       end
-      
     end
-    def assert_exists
-      unless @option
-        raise UnknownObjectException,
-                    "Unable to locate an option using #{@how} and #{@what}"
+
+    def clear
+      raise TypeError, "you can only clear multi-selects" unless select_list.multiple?
+
+      perform_action do
+        if selected?
+          ole_object.selected = false
+          select_list.dispatch_event("onChange")
+          @container.wait
+        end
       end
     end
-    private :assert_exists
-    
-    # select the accessed option in select_list
-    def select
+
+    def selected?
       assert_exists
-      @select_list.select_item_in_select_list(@how, @what)
+      ole_object.selected
+    end
+
+    def text
+      l = label
+      l.empty? ? super : l rescue ''
+    end
+
+    private
+
+    def select_list
+      return @select_list if @select_list
+      el = parent
+      el = el.parent until el.is_a?(SelectList)
+
+      raise "SELECT element was not found for #{self}!" unless el
+      @select_list = el
     end
   end
-  
+
   # 
   # Input: Button
   #
@@ -224,6 +145,16 @@ module Watir
     #:stopdoc:
     INPUT_TYPES = ["button", "submit", "image", "reset"]
     #:startdoc:
+    
+    alias_method :__value, :value
+
+    def text
+      val = __value
+      val.empty? ? super : val
+    end
+
+    alias_method :value, :text
+
   end
 
   #
@@ -242,6 +173,8 @@ module Watir
     #   Raises UnknownObjectException if the object can't be found.
     def_wrap :readonly?, :readOnly
 
+    alias_method :text, :value
+
     #:startdoc:
     
     # return number of maxlength attribute
@@ -254,7 +187,6 @@ module Watir
       end
     end
         
-    
     def text_string_creator
       n = []
       n << "length:".ljust(TO_S_SIZE) + self.size.to_s
@@ -442,6 +374,10 @@ module Watir
       end
       value
     end
+
+    def label
+      @container.label(:for => name).text
+    end
   end
   
   # this class can be used to access hidden field objects

data/lib/watir/locator.rb

@@ -3,6 +3,28 @@ module Watir
     include Watir
     include Watir::Exception
 
+    def initialize container, tags, klass
+      @container = container
+      @tags = tags
+      @klass = klass
+    end
+
+    def each
+      if has_excluding_specifiers?
+        locate_elements_by_xpath_css_ole.each do |element|
+          yield element
+        end
+      else
+        @tags.each do |tag|
+          each_element(tag) do |element| 
+            next unless type_matches?(element.ole_object) && match_with_specifiers?(element)
+            yield element          
+          end 
+        end
+      end
+      nil
+    end    
+
     def document
       @document ||= @container.document
     end
@@ -30,7 +52,11 @@ module Watir
 
     def match_with_specifiers?(element)
       return true if has_excluding_specifiers?
-      @specifiers.all? {|how, what| how == :index || match?(element, how, what)}
+      @specifiers.all? do |how, what|
+        how == :index || 
+          (how.to_s =~ /^data_.*/ && element.send(how) == what) || 
+           match?(element, how, what)
+      end
     end
 
     def has_excluding_specifiers?
@@ -42,7 +68,7 @@ module Watir
       @specifiers = {:index => Watir::IE.base_index} # default if not specified
       normalize_specifiers! specifiers
     end
-    
+
     def locate_by_id
       # Searching through all elements returned by __ole_inner_elements
       # is *significantly* slower than IE's getElementById() and
@@ -57,20 +83,30 @@ module Watir
       if the_id && the_id.class == String 
         element = document.getElementById(the_id) rescue nil
         # Return if our fast match really HAS a matching :id
-        return element if element && element.invoke('id') == the_id 
+        return element if element && element.invoke('id') == the_id && type_matches?(element) && match_with_specifiers?(create_element element)
       end
 
       nil
     end
 
-    def locate_by_xpath_css_ole
+    def locate_elements_by_xpath_css_ole
+      els = []
+
       if @specifiers[:xpath]
-        return @container.element_by_xpath(@specifiers[:xpath])
+        els = @container.send(:elements_by_xpath, @specifiers[:xpath])
       elsif @specifiers[:css]
-        return @container.element_by_css(@specifiers[:css])
+        els = @container.send(:elements_by_css, @specifiers[:css])
       elsif @specifiers[:ole_object]
-        return @specifiers[:ole_object]
+        return [@specifiers[:ole_object]]
       end      
+
+      els.select {|element| type_matches?(element) && match_with_specifiers?(create_element element)}
+    end
+
+    def type_matches?(el)
+      @tags == ["*"] || 
+        @tags.include?(el.tagName) || 
+        @tags.include?(el.invoke('type')) rescue false
     end
 
     def create_element ole_object
@@ -86,30 +122,16 @@ module Watir
   end
 
   class TaggedElementLocator < Locator
-    def initialize(container, tag, klass)
-      @container = container
-      @tag = tag
-      @klass = klass || Element
-    end
-
-    def each_element tag
+    def each_element(tag)
       document.getElementsByTagName(tag).each do |ole_object|
         yield create_element ole_object
       end
     end
 
-    def each
-      each_element(@tag) do |element| 
-        next unless match_with_specifiers?(element)
-        yield element          
-      end 
-      nil
-    end    
-
     def locate
       el = locate_by_id
       return el if el
-      return locate_by_xpath_css_ole if has_excluding_specifiers?
+      return locate_elements_by_xpath_css_ole[0] if has_excluding_specifiers?
 
       count = Watir::IE.base_index - 1
       each do |element|
@@ -124,7 +146,7 @@ module Watir
         method = element.method(how)
       rescue NameError
         raise MissingWayOfFindingObjectException,
-          "#{how} is an unknown way of finding a <#{@tag || @tags.join(", ")}> element (#{what})"
+          "#{how} is an unknown way of finding a <#{@tags.join(", ")}> element (#{what})"
       end
       case method.arity
       when 0
@@ -133,18 +155,14 @@ module Watir
         method.call(what)
       else
         raise MissingWayOfFindingObjectException,
-          "#{how} is an unknown way of finding a <#{@tag || @tags.join(", ")}> element (#{what})"
+          "#{how} is an unknown way of finding a <#{@tags.join(", ")}> element (#{what})"
       end
     end
 
   end
 
   class FrameLocator < TaggedElementLocator
-    def initialize(container)
-      super(container, Frame::TAG, Frame)
-    end
-
-    def each_element tag
+    def each_element(tag)
       frames = document.frames
       i = 0
       document.getElementsByTagName(tag).each do |ole_object|
@@ -155,21 +173,9 @@ module Watir
       end
     end
 
-    def each
-      @tag.each do |t|
-        each_element(t) do |element| 
-          next unless match_with_specifiers?(element)
-          yield element          
-        end 
-      end
-      nil
-    end        
-
     def locate
-      # do not locate frames by getElementById since can't get the correct
+      # do not locate frames by getElementById or by xpath since can't get the correct
       # 'document' related with that ole_object like it's done in #each_element
-      return locate_by_xpath_css_ole if has_excluding_specifiers?
-
       count = Watir::IE.base_index - 1
       each do |frame|
         count += 1
@@ -179,10 +185,6 @@ module Watir
   end
 
   class FormLocator < TaggedElementLocator
-    def initialize(container)
-      super(container, 'FORM', Form)
-    end
-
     def each_element(tag)
       document.forms.each do |form|
         yield create_element form
@@ -191,12 +193,6 @@ module Watir
   end
 
   class InputElementLocator < Locator
-    def initialize container, types, klass
-      @container = container
-      @types = types
-      @klass = klass || Element
-    end
-
     def each_element
       elements = locate_by_name || @container.__ole_inner_elements
       elements.each do |object|
@@ -208,7 +204,7 @@ module Watir
     def locate
       el = locate_by_id
       return el if el
-      return locate_by_xpath_css_ole if has_excluding_specifiers?
+      return locate_elements_by_xpath_css_ole[0] if has_excluding_specifiers?
 
       count = Watir::IE.base_index - 1
       each do |element|
@@ -218,13 +214,19 @@ module Watir
     end
 
     def each
-      each_element do |element| 
-        next unless @types.include?(element.type) && match_with_specifiers?(element)
-        yield element
-      end 
+      if has_excluding_specifiers?
+        locate_elements_by_xpath_css_ole.each do |element|
+          yield element
+        end
+      else
+        each_element do |element| 
+          next unless type_matches?(element.ole_object) && match_with_specifiers?(element)
+          yield element
+        end 
+      end
       nil
     end    
-    
+
     # return true if the element matches the provided how and what
     def match? element, how, what
       begin
@@ -248,11 +250,4 @@ module Watir
     end
   end
 
-  # This is like the TaggedElementLocator but
-  # get all the elements by forcing @tag to be '*'
-  class ElementLocator < TaggedElementLocator
-    def initialize(container)
-      super(container, "*", Element)
-    end
-  end  
 end