watir 3.0.0.rc2 → 3.0.0.rc3

data/lib/watir/non_control_elements.rb

@@ -1,82 +1,114 @@
 module Watir
+  class Area < Element
+    attr_ole :alt
+    attr_ole :type
+    attr_ole :href
+  end
+
+  class Audio < Element
+    attr_ole :src
+  end
+
+  class Base < Element
+    attr_ole :href
+  end
+
+  class Command < Element
+    attr_ole :disabled?
+    attr_ole :type
+  end
+
+  class Data < Element
+    attr_ole :value
+  end
+
+  class Embed < Element
+    attr_ole :src
+    attr_ole :type
+  end
+
+  class FieldSet < Element
+    attr_ole :name
+    attr_ole :disabled?
+  end
+
+  class Font < Element
+    attr_ole :color
+    attr_ole :face
+    attr_ole :size
+  end
+
+  class Keygen < Element
+    attr_ole :name
+    attr_ole :disabled?
+  end
+
+  class Label < Element
+    attr_ole :for, :htmlFor
+  end
+
+  class Li < Element
+    attr_ole :value
+  end
+
+  class Map < Element
+    attr_ole :name
+  end
+
+  class Menu < Element
+    attr_ole :type
+  end
+
+  class Meta < Element
+    attr_ole :http_equiv, :httpEquiv
+    attr_ole :content
+    attr_ole :name
+  end
+
+  class Meter < Element
+    attr_ole :value
+  end
+
+  class Object < Element
+    attr_ole :name
+    attr_ole :type
+  end
+
+  class Optgroup < Element
+    attr_ole :disabled?
+  end
+
+  class Output < Element
+    attr_ole :name
+  end
+
+  class Param < Element
+    attr_ole :name
+    attr_ole :value
+  end
+
+  class Progress < Element
+    attr_ole :value
+  end
+
+  class Script < Element
+    attr_ole :src
+    attr_ole :type
+  end
+
+  class Source < Element
+    attr_ole :type
+  end
+
+  class Style < Element
+    attr_ole :type
+  end
 
-  # this class contains items that are common between the span, div, and pre objects
-  # it would not normally be used directly
-  #
-  # many of the methods available to this object are inherited from the Element class
-  #
-  class NonControlElement < Element
-    include Watir::Exception
-
-    def initialize(container, how, what)
-      set_container container
-      @how = how
-      @what = what
-      super nil
-    end
-
-    # this method is used to populate the properties in the to_s method
-    def span_div_string_creator
-      n = []
-      n <<   "class:".ljust(TO_S_SIZE) + self.class_name
-      n <<   "text:".ljust(TO_S_SIZE) + self.text
-      return n
-    end
-    private :span_div_string_creator
-
-    # returns the properties of the object in a string
-    # raises an ObjectNotFound exception if the object cannot be found
-    def to_s
-      assert_exists
-      r = string_creator
-      r += span_div_string_creator
-      return r.join("\n")
-    end
-  end
-
-  # Accesses Label element on the html page - http://msdn.microsoft.com/workshop/author/dhtml/reference/objects/label.asp?frame=true
-  class Label < NonControlElement
-    # this method is used to populate the properties in the to_s method
-    def label_string_creator
-      n = []
-      n <<   "for:".ljust(TO_S_SIZE) + self.for
-      n <<   "text:".ljust(TO_S_SIZE) + self.text
-      return n
-    end
-    private :label_string_creator
-
-    # returns the properties of the object in a string
-    # raises an ObjectNotFound exception if the object cannot be found
-    def to_s
-      assert_exists
-      r = string_creator
-      r += label_string_creator
-      return r.join("\n")
-    end
-  end
-
-  class Ins < NonControlElement
-    Watir::Container.module_eval do
-      remove_method :inss
-
-      def inses(how={}, what=nil)
-        Inses.new(self, how, what)
-      end
-    end
-  end
-
-  class FieldSet < NonControlElement
-    Watir::Container.module_eval do
-      alias_method :fieldset, :field_set
-      alias_method :fieldsets, :field_sets
-    end
-  end
-
-  %w[Pre P Div Span Map Area Li Ul H1 H2 H3 H4 H5 H6
-     Dl Dt Dd Strong Em Del Ol Body Meta Font Frameset].each do |elem|
-    module_eval %Q{
-      class #{elem} < NonControlElement; end
-    }
-  end
-  
+  class Track < Element
+    attr_ole :src
+  end
+
+  class Video < Element
+    attr_ole :src
+  end
 end

data/lib/watir/page-container.rb

@@ -33,6 +33,17 @@ module Watir
 
     private :page
 
+    # Execute the given JavaScript string
+    def execute_script(source)
+      document.parentWindow.eval(source.to_s)
+    rescue WIN32OLERuntimeError, NoMethodError #if eval fails we need to use execScript(source.to_s) which does not return a value, hence the workaround
+      escaped_src = source.to_s.gsub(/[\r\n']/) {|m| "\\#{m}"}
+      wrapper = "_watir_helper_div_#{::Time.now.to_i + ::Time.now.usec}"
+      cmd = "var e = document.createElement('DIV'); e.style.display='none'; e.id='#{wrapper}'; e.innerHTML = eval('#{escaped_src}'); document.body.appendChild(e);"
+      document.parentWindow.execScript(cmd)
+      document.getElementById(wrapper).innerHTML
+    end
+
     # The HTML of the current page
     def html
       page.outerhtml
@@ -94,4 +105,4 @@ module Watir
     end
 
   end # module
-end
+end

data/lib/watir/supported_elements.rb

@@ -0,0 +1,172 @@
+module Watir
+  module Container
+
+    class << self
+      def support_element method_name, args={}
+        klass = args[:class] || method_name.to_s.capitalize
+        super_class = args[:super_class] || "Element"
+
+        unless Watir.const_defined? klass
+          Watir.class_eval %Q[class #{klass} < #{super_class}; end]
+        end
+
+        unless Watir.const_defined? "#{klass}Collection"
+          Watir.class_eval %Q[class #{klass}Collection < #{args[:super_collection] || super_class}Collection; end]
+        end
+
+        tag_name = args[:tag_name] || method_name
+
+        Watir::Container.module_eval %Q[
+          def #{method_name}(how={}, what=nil)
+            #{klass}.new(self, format_specifiers(#{tag_name.inspect}, how, what))
+          end
+
+          def #{args.delete(:plural) || method_name.to_s + "s"}(how={}, what=nil)
+            specifiers = format_specifiers(#{tag_name.inspect}, how, what)
+            #{klass}Collection.new(self, specifiers)
+          end
+        ]
+      end
+
+      private :support_element
+    end
+
+    def format_specifiers(tag_name, how, what)
+      defaults = {:tag_name => [tag_name].flatten.map(&:to_s)}
+      formatted_specifiers = defaults.merge(what ? {how => what} : how)
+      if (formatted_specifiers[:css] || formatted_specifiers[:xpath]) && formatted_specifiers.size > 2
+        raise ArgumentError, ":xpath and :css specifiers should be the only one when used in #{formatted_specifiers.inspect}"
+      end
+      formatted_specifiers
+    end
+
+    private :format_specifiers
+
+    support_element :a, :class => :Link
+    alias_method :link, :a
+    alias_method :links, :as
+    support_element :abbr
+    support_element :address, :plural => :addresses
+    support_element :area
+    support_element :article
+    support_element :aside
+    support_element :audio
+    support_element :b
+    support_element :base
+    support_element :bdi
+    support_element :bdo
+    support_element :blockquote
+    support_element :body
+    support_element :br
+    support_element :button, :tag_name => [:button, :submit, :image, :reset], :super_class => :InputElement
+    support_element :canvas, :plural => :canvases 
+    support_element :caption
+    support_element :checkbox, :plural => :checkboxes, :class => :CheckBox, :super_class => :InputElement
+    support_element :cite
+    support_element :code
+    support_element :col
+    support_element :colgroup
+    support_element :command
+    support_element :data
+    support_element :datalist
+    support_element :dd
+    support_element :del
+    support_element :details, :plural => :detailses
+    support_element :dfn
+    support_element :div
+    support_element :dl
+    support_element :dt
+    support_element :element, :tag_name => "*", :class => :HTMLElement
+    support_element :em
+    support_element :embed
+    support_element :fieldset, :class => :FieldSet
+    alias_method :field_set, :fieldset
+    alias_method :field_sets, :fieldsets
+    support_element :figcaption
+    support_element :figure
+    support_element :file_field, :tag_name => :file, :class => :FileField, :super_collection => :InputElement
+    support_element :font
+    support_element :footer
+    support_element :form
+    support_element :frame, :tag_name => [:frame, :iframe]
+    alias_method :iframe, :frame
+    alias_method :iframes, :frames
+    support_element :frameset
+    support_element :h1
+    support_element :h2
+    support_element :h3
+    support_element :h4
+    support_element :h5
+    support_element :h6
+    support_element :head
+    support_element :header
+    support_element :hgroup
+    support_element :hidden, :super_class => :TextField, :super_collection => :InputElement
+    support_element :hr
+    # html and htmls?!
+    support_element :i
+    support_element :img, :class => :Image
+    alias_method :image, :img
+    alias_method :images, :imgs
+    support_element :input, :super_class => :InputElement
+    support_element :ins, :plural => :inses
+    support_element :kbd
+    support_element :keygen
+    support_element :label
+    support_element :legend
+    support_element :li
+    support_element :map
+    support_element :mark
+    support_element :menu
+    support_element :meta
+    support_element :meter
+    support_element :nav
+    support_element :noscript
+    support_element :object
+    support_element :ol
+    support_element :optgroup
+    support_element :option
+    support_element :output
+    support_element :p
+    support_element :param
+    support_element :pre
+    support_element :progress, :plural => :progresses
+    support_element :q
+    support_element :radio, :super_class => :InputElement
+    support_element :rp
+    support_element :rt
+    support_element :ruby, :plural => :rubies
+    support_element :s
+    support_element :samp
+    support_element :script
+    support_element :section
+    support_element :select, :class => :SelectList, :super_class => :InputElement
+    alias_method :select_list, :select
+    alias_method :select_lists, :selects
+    support_element :small
+    support_element :source
+    support_element :span
+    support_element :strong
+    support_element :style
+    support_element :sub
+    support_element :summary, :plural => :summaries
+    support_element :sup
+    support_element :table
+    support_element :tbody, :class => :TableSection
+    support_element :td, :tag_name => [:th, :td], :class => :TableCell
+    support_element :text_field, :tag_name => [:text, :password, :textarea], :class => :TextField, :super_class => :InputElement
+    support_element :textarea, :class => :TextArea, :super_class => :TextField, :super_collection => :InputElement
+    support_element :tfoot, :class => :TableSection
+    support_element :th
+    support_element :thead, :class => :TableSection
+    support_element :time
+    support_element :title
+    support_element :tr, :class => :TableRow
+    support_element :track
+    support_element :u
+    support_element :ul
+    support_element :var
+    support_element :video
+    support_element :wbr
+  end
+end

data/lib/watir/table.rb

@@ -1,11 +1,11 @@
 module Watir
 
-  module RowContainer
+  module TableContainer
     # Returns a row in the table
     #   * index         - the index of the row
     def [](index)
       assert_exists
-      TableRow.new(self, :ole_object, @o.rows.item(index))
+      TableRow.new(self, :ole_object => @o.rows.item(index))
     end
     
     def strings
@@ -14,13 +14,51 @@ module Watir
       @o.rows.each do |row|
         cells_memo = []
         row.cells.each do |cell|
-          cells_memo << TableCell.new(self, :ole_object, cell).text.gsub("\r\n","")
+          cells_memo << TableCell.new(self, :ole_object => cell).text.gsub("\r\n","")
         end
         rows_memo << cells_memo
       end
       rows_memo
     end
+  end
+
+  module TableElementsContainer
+    def table_elements(klass, tags, how, what, ole_collection)
+      specifiers = format_specifiers(tags, how, what)
+      klass.new(self, specifiers, ole_collection)
+    end
+
+    private :table_elements
+  end
+
+  module TableCellsContainer
+    include TableElementsContainer
+
+    def cells(how={}, what=nil)
+      assert_exists
+      table_elements(TableCellCollection, [:th, :td], how, what, @o.cells)
+    end
 
+    def cell(how={}, what=nil)
+      specifiers = format_specifiers([:th, :td], how, what)
+      index = specifiers.delete(:index) || 0
+      cells(specifiers)[index]
+    end
+  end
+
+  module TableRowsContainer
+    include TableElementsContainer
+
+    def rows(how={}, what=nil)
+      assert_exists
+      table_elements(TableRowCollection, [:tr], how, what, @o.rows)
+    end
+
+    def row(how={}, what=nil)
+      specifiers = format_specifiers([:tr], how, what)
+      index = specifiers.delete(:index) || 0
+      rows(specifiers)[index]
+    end
   end
 
   # This class is used for dealing with tables.
@@ -28,8 +66,12 @@ module Watir
   #
   # many of the methods available to this object are inherited from the Element class
   #
-  class Table < NonControlElement
-    include RowContainer
+  class Table < Element
+    include TableContainer
+    include TableRowsContainer
+    include TableCellsContainer
+
+    attr_ole :rules
 
     # override the highlight method, as if the tables rows are set to have a background color,
     # this will override the table background color, and the normal flash method won't work
@@ -76,14 +118,6 @@ module Watir
       return r.join("\n")
     end
     
-    # iterates through the rows in the table. Yields a TableRow object
-    def each
-      assert_exists
-      @o.rows.each do |row| 
-        yield TableRow.new(self, :ole_object, row)
-      end
-    end
-    
     # Returns the number of rows inside the table, including rows in nested tables.
     def row_count
       assert_exists
@@ -95,7 +129,7 @@ module Watir
     #   * index         - the index of the row
     def column_count(index=0)
       assert_exists
-      row[index].cells.length
+      rows[index].cells.length
     end
     
     # Returns an array containing all the text values in the specified column
@@ -119,7 +153,7 @@ module Watir
 
       headers = []
       @o.rows.item(0).cells.each do |cell|
-        headers << TableCell.new(self, :ole_object, cell).text
+        headers << TableCell.new(self, :ole_object => cell).text
       end
 
       rows_memo = []
@@ -133,7 +167,7 @@ module Watir
 
         j = 0
         cells.each do |cell|
-          cells_memo[headers[j]] = TableCell.new(self, :ole_object, cell).text
+          cells_memo[headers[j]] = TableCell.new(self, :ole_object => cell).text
           j += 1
         end
 
@@ -144,45 +178,15 @@ module Watir
     end
   end
 
-  class TableSection < NonControlElement
-    include RowContainer
-
-    Watir::Container.module_eval do
-      def tbody(how={}, what=nil)
-        how = {how => what} if what
-        TableSection.new(self, how.merge(:tag_name => "tbody"), nil)
-      end
-
-      def tbodys(how={}, what=nil)
-        how = {how => what} if what
-        TableSectionCollection.new(self, how.merge(:tag_name => "tbody"), nil)
-      end
-
-      def thead(how={}, what=nil)
-        how = {how => what} if what
-        TableSection.new(self, how.merge(:tag_name => "thead"), nil)
-      end
-
-      def theads(how={}, what=nil)
-        how = {how => what} if what
-        TableSectionCollection.new(self, how.merge(:tag_name => "thead"), nil)
-      end
-
-      def tfoot(how={}, what=nil)
-        how = {how => what} if what
-        TableSection.new(self, how.merge(:tag_name => "tfoot"), nil)
-      end
-
-      def tfoots(how={}, what=nil)
-        how = {how => what} if what
-        TableSectionCollection.new(self, how.merge(:tag_name => "tfoot"), nil)
-      end
-    end
+  class TableSection < Element
+    include TableContainer
+    include TableRowsContainer
+    include TableCellsContainer
   end
 
-  class TableRow < NonControlElement
-    TAG = "TR"
-    
+  class TableRow < Element
+    include TableCellsContainer
+
     # this method iterates through each of the cells in the row. Yields a TableCell object
     def each
       locate
@@ -198,55 +202,23 @@ module Watir
       return cells[index]
     end
     
-    # defaults all missing methods to the array of elements, to be able to
-    # use the row as an array
-    #        def method_missing(aSymbol, *args)
-    #            return @o.send(aSymbol, *args)
-    #        end
     def column_count
-      locate
+      assert_exists
       cells.length
     end
 
-    Watir::Container.module_eval do
-      def row(how={}, what=nil)
-        TableRow.new(self, how, what)
-      end
-
-      alias_method :tr, :row
-
-      def rows(how={}, what=nil)
-        TableRows.new(self, how, what)
-      end
-
-      alias_method :trs, :rows
-    end
   end
   
   # this class is a table cell - when called via the Table object
-  class TableCell < NonControlElement
-    TAGS = ["TH", "TD"]
+  class TableCell < Element
+    attr_ole :headers
 
-    alias to_s text
+    alias_method :to_s, :text
     
     def colspan
       locate
       @o.colSpan
     end
-    
-    Watir::Container.module_eval do
-      def cell(how={}, what=nil)
-        TableCell.new(self, how, what)
-      end
-
-      alias_method :td, :cell
-
-      def cells(how={}, what=nil)
-        TableCells.new(self, how, what)
-      end
-
-      alias_method :tds, :cells
-    end
   end
   
 end