celerity 0.0.4 → 0.0.6

data/lib/celerity/clickable_element.rb

@@ -1,12 +1,53 @@
 module Celerity
   module ClickableElement
-    
-    # clicks the element
+
+    #
+    # click the element
+    #
+
     def click
-      assert_exists
-      assert_enabled
+      assert_exists_and_enabled
       @container.update_page(@object.click)
-    end 
-    
+    end
+
+    #
+    # double click the element (Celerity only)
+    #
+
+    def double_click
+      assert_exists_and_enabled
+      @container.update_page(@object.dblClick)
+    end
+
+    #
+    # right click the element (Celerity only)
+    #
+
+    def right_click
+      assert_exists_and_enabled
+      @container.update_page(@object.rightClick)
+    end
+
+    #
+    # Click the element and return a new Browser instance with the resulting page.
+    # This is useful for elements that trigger popups when clicked.
+    #
+    # @return [Celerity::Browser]
+    #
+
+    def click_and_attach
+      assert_exists_and_enabled
+      browser = Browser.new(:log_level => @browser.log_level)
+      browser.update_page(@object.click)
+
+      browser
+    end
+
+    private
+
+    def assert_exists_and_enabled
+      assert_exists
+      assert_enabled if respond_to?(:assert_enabled)
+    end
   end
-end
+end

data/lib/celerity/collections.rb

@@ -1,132 +1,156 @@
-module Celerity
-
- class Frames < ElementCollections
-    def element_class; Frame; end
-  end
-  
- class Buttons < ElementCollections
-    def element_class; Button; end
-  end
-
-  class FileFields < ElementCollections
-    def element_class; FileField; end
-  end
-
-  class CheckBoxes < ElementCollections
-    def element_class; CheckBox; end
-  end
-
-  class Radios < ElementCollections
-    def element_class; Radio; end
-  end
-
-  class SelectLists < ElementCollections
-    def element_class; SelectList; end
-  end
-
-  class Links < ElementCollections
-    def element_class; Link; end
-  end
-
-  class Uls < ElementCollections
-    def element_class; Ul; end
-  end
-  
-  class Ols < ElementCollections
-    def element_class; Ol; end
-  end
-  
-  class Lis < ElementCollections
-    def element_class; Li; end
-  end
-
-  class Maps < ElementCollections
-    def element_class; Map; end
-  end
-
-  class Areas < ElementCollections
-    def element_class; Area; end
-  end
-
-  class Images < ElementCollections
-    def element_class; Image; end
-  end
-
-  class TextFields < ElementCollections
-    def element_class; TextField; end
-  end
-
-  class Hiddens < ElementCollections
-    def element_class; Hidden; end
-  end
-
-  class Tables < ElementCollections
-    def element_class; Table; end
-  end
-  
-  class TableHeaders < ElementCollections
-    def element_class; TableHeader; end
-  end
-  class TableBodies < ElementCollections
-    def element_class; TableBody; end
-  end
-  class TableFooters < ElementCollections
-    def element_class; TableFooter; end
-  end
-
-  class TableRows < ElementCollections
-    def element_class; TableRow; end
-  end
-
-  class TableCells < ElementCollections
-    def element_class; TableCell; end
-  end
-
-  class Labels < ElementCollections
-    def element_class; Label; end
-  end
-
-  class Pres < ElementCollections
-    def element_class; Pre; end
-  end
-
-  class Ps < ElementCollections
-    def element_class; P; end
-  end
-
-  class Spans < ElementCollections
-    def element_class; Span; end
-  end
-
-  class Divs < ElementCollections
-    def element_class; Div; end
-  end
-  
-  class Forms < ElementCollections
-    def element_class; Form; end
-  end
-  
-  class Options < ElementCollections
-    def element_class; Option; end
-  end
-  
-  class H1s < ElementCollections
-    def element_class; H1; end
-  end
-  class H2s < ElementCollections
-    def element_class; H2; end
-  end
-  class H3s < ElementCollections
-    def element_class; H3; end
-  end
-  class H4s < ElementCollections
-    def element_class; H4; end
-  end
-  class H5s < ElementCollections
-    def element_class; H5; end
-  end
-  class H6s < ElementCollections
-    def element_class; H6; end
-  end
-
+module Celerity
+
+ class Frames < ElementCollection
+    def element_class; Frame; end
+  end
+
+ class Buttons < ElementCollection
+    def element_class; Button; end
+  end
+
+  class FileFields < ElementCollection
+    def element_class; FileField; end
+  end
+
+  class CheckBoxes < ElementCollection
+    def element_class; CheckBox; end
+  end
+
+  class Radios < ElementCollection
+    def element_class; Radio; end
+  end
+
+  class SelectLists < ElementCollection
+    def element_class; SelectList; end
+  end
+
+  class Links < ElementCollection
+    def element_class; Link; end
+  end
+
+  class Uls < ElementCollection
+    def element_class; Ul; end
+  end
+
+  class Ols < ElementCollection
+    def element_class; Ol; end
+  end
+
+  class Lis < ElementCollection
+    def element_class; Li; end
+  end
+
+  class Dds < ElementCollection
+    def element_class; Dd; end
+  end
+
+  class Dls < ElementCollection
+    def element_class; Dl; end
+  end
+
+  class Dts < ElementCollection
+    def element_class; Dt; end
+  end
+  
+  class Ems < ElementCollection
+    def element_class; Em; end
+  end
+
+  class Maps < ElementCollection
+    def element_class; Map; end
+  end
+
+  class Areas < ElementCollection
+    def element_class; Area; end
+  end
+
+  class Images < ElementCollection
+    def element_class; Image; end
+  end
+
+  class TextFields < ElementCollection
+    def element_class; TextField; end
+  end
+
+  class Hiddens < ElementCollection
+    def element_class; Hidden; end
+  end
+
+  class Tables < ElementCollection
+    def element_class; Table; end
+  end
+
+  class TableHeaders < ElementCollection
+    def element_class; TableHeader; end
+  end
+  class TableBodies < ElementCollection
+    def element_class; TableBody; end
+  end
+  class TableFooters < ElementCollection
+    def element_class; TableFooter; end
+  end
+
+  class TableRows < ElementCollection
+    def element_class; TableRow; end
+  end
+
+  class TableCells < ElementCollection
+    def element_class; TableCell; end
+  end
+
+  class Labels < ElementCollection
+    def element_class; Label; end
+  end
+
+  class Pres < ElementCollection
+    def element_class; Pre; end
+  end
+
+  class Ps < ElementCollection
+    def element_class; P; end
+  end
+
+  class Spans < ElementCollection
+    def element_class; Span; end
+  end
+  
+  class Strongs < ElementCollection
+    def element_class; Strong; end
+  end
+
+  class Divs < ElementCollection
+    def element_class; Div; end
+  end
+
+  class Forms < ElementCollection
+    def element_class; Form; end
+  end
+
+  class Options < ElementCollection
+    def element_class; Option; end
+  end
+
+  class Metas < ElementCollection
+    def element_class; Meta; end
+  end
+
+  class H1s < ElementCollection
+    def element_class; H1; end
+  end
+  class H2s < ElementCollection
+    def element_class; H2; end
+  end
+  class H3s < ElementCollection
+    def element_class; H3; end
+  end
+  class H4s < ElementCollection
+    def element_class; H4; end
+  end
+  class H5s < ElementCollection
+    def element_class; H5; end
+  end
+  class H6s < ElementCollection
+    def element_class; H6; end
+  end
+
 end

data/lib/celerity/container.rb

@@ -1,385 +1,766 @@
-module Celerity
-  
-  # This class contains methods for accessing elements inside a container.
-  # (usually the Browser object, meaning the current page).
-  #
-  # The most common syntax is 
-  #   browser.elem(:attribute, 'value')
-  #
-  # Note that the element is located lazily, so no exceptions will be thrown 
-  # if the element doesn't exist until you call a method on the resulting object. 
-  # To do this you would normally use +Element#exists?+ or an action method, 
-  # like +ClickableElement#click+. 
-  # 
-  # You can also pass in a hash:
-  #
-  #   browser.link(:index => 1).click
-  #
-  # All elements support multiple attributes identification using the 
-  # hash syntax (though might not always be compatible with Watir):
-  #
-  # browser.span(:class_name => 'product', :index => 5).text
-  #
-  # You can also get all the elements of a certain type by using the plural form:
-  #
-  # browser.links => #<Celerity::Links:0x7a1c2da2 ...>
-  # 
-  # See +Celerity::ElementCollections+ for details.
-  module Container
-    include Celerity::Exception
-    attr_accessor :page_container
-
-    def container=(container)
-      @container = container
-      @page_container = container.page_container
-      container
-    end
-
-    def update_page(page)
-      @page_container.page = page 
-    end
-
-    def frame(*args)
-      assert_exists
-      Frame.new(self, *args)
-    end
-
-    def frames
-      assert_exists
-      Frames.new(self)
-    end
-
-    def table(*args)
-      assert_exists
-      Table.new(self, *args)
-    end
-    
-    def tables
-      assert_exists
-      Tables.new(self)
-    end
-    
-    def thead(*args)
-      assert_exists
-      TableHeader.new(self, *args)
-    end
-    
-    def theads
-      assert_exists
-      TableHeaders.new(self)
-    end
-    
-    def tbody(*args)
-      assert_exists
-      TableBody.new(self, *args)
-    end
-    
-    def tbodies
-      assert_exists
-      TableBodies.new(self)
-    end
-    
-    def tfoot(*args)
-      assert_exists
-      TableFooter.new(self, *args)
-    end
-    
-    def tfoots
-      assert_exists
-      TableFooters.new(self)
-    end
-    alias_method :tfeet, :tfoots # :-)
-
-    def cell(*args)
-      assert_exists
-      TableCell.new(self, *args)
-    end
-    
-    def cells
-      assert_exists
-      TableCells.new(self)
-    end
-
-    def row(*args)
-      assert_exists
-      TableRow.new(self, *args)
-    end
-    
-    def rows
-      assert_exists
-      TableRows.new(self)
-    end
-
-    def button(*args)
-      assert_exists
-      Button.new(self, *args)
-    end
-    
-    def buttons
-      assert_exists
-      Buttons.new(self)
-    end
-
-    def file_field(*args)
-      assert_exists
-      FileField.new(self, *args)
-    end
-    
-    def file_fields
-      assert_exists
-      FileFields.new(self)
-    end
-
-    def text_field(*args)
-      assert_exists
-      TextField.new(self, *args)
-    end
-    
-    def text_fields
-      assert_exists
-      TextFields.new(self)
-    end
-
-    def hidden(*args)
-      assert_exists
-      Hidden.new(self, *args)
-    end
-    
-    def hiddens
-      assert_exists
-      Hiddens.new(self)
-    end
-
-    def select_list(*args)
-      assert_exists
-      SelectList.new(self, *args)
-    end
-    
-    def select_lists
-      assert_exists
-      SelectLists.new(self)
-    end
-    
-    def option(*args)
-      assert_exists
-      Option.new(self, *args)
-    end
-
-    def check_box(*args)
-      assert_exists
-      CheckBox.new(self, *args)
-    end
-
-    def checkboxes
-      assert_exists
-      CheckBoxes.new(self)
-    end
-
-    def radio(*args)
-      assert_exists
-      Radio.new(self, *args)
-    end
-    
-    def radios
-      assert_exists
-      Radios.new(self)
-    end
-
-    def link(*args)
-      assert_exists
-      Link.new(self, *args)
-    end
-
-    def links
-      assert_exists
-      Links.new(self)
-    end
-    
-    def ul(*args)
-      assert_exists
-      Ul.new(self, *args)
-    end
-    
-    def uls
-      assert_exists
-      Uls.new(self)
-    end
-    
-    def ol(*args)
-      assert_exists
-      Ol.new(self, *args)
-    end
-    
-    def ols
-      assert_exists
-      Ols.new(self)
-    end
-
-    def li(*args)
-      assert_exists
-      Li.new(self, *args)
-    end
-    
-    def lis
-      assert_exists
-      Lis.new(self)
-    end
-
-    def map(*args)
-      assert_exists
-      Map.new(self, *args)
-    end
-    
-    def maps
-      assert_exists
-      Maps.new(self)
-    end
-
-    def area(*args)
-      assert_exists
-      Area.new(self, *args)
-    end
-    
-    def areas
-      assert_exists
-      Areas.new(self)
-    end
-
-    def image(*args)
-      assert_exists
-      Image.new(self, *args)
-    end
-    
-    def images
-      assert_exists
-      Images.new(self)
-    end
-
-    def div(*args)
-      assert_exists
-      Div.new(self, *args)
-    end
-    
-    def divs
-      assert_exists
-      Divs.new(self)
-    end
-
-    def form(*args)
-      assert_exists
-      Form.new(self, *args)
-    end
-    
-    def forms
-      assert_exists
-      Forms.new(self)
-    end
-
-    def span(*args)
-      assert_exists
-      Span.new(self, *args)
-    end
-    
-    def spans
-      assert_exists
-      Spans.new(self)
-    end
-
-    def p(*args)
-      assert_exists
-      P.new(self, *args)
-    end
-    
-    def ps
-      assert_exists
-      Ps.new(self)
-    end
-
-    def pre(*args)
-      assert_exists
-      Pre.new(self, *args)
-    end
-    
-    def pres
-      assert_exists
-      Pres.new(self)
-    end
-
-    def label(*args)
-      assert_exists
-      Label.new(self, *args)
-    end
-    
-    def labels
-      assert_exists
-      Labels.new(self)
-    end
-    
-    def h1(*args)
-      assert_exists
-      H1.new(self, *args)
-    end
-    
-    def h2(*args)
-      assert_exists
-      H2.new(self, *args)
-    end
-    
-    def h3(*args)
-      assert_exists
-      H3.new(self, *args)
-    end
-    
-    def h4(*args)
-      assert_exists
-      H4.new(self, *args)
-    end
-    
-    def h5(*args)
-      assert_exists
-      H5.new(self, *args)
-    end
-    
-    def h6(*args)
-      assert_exists
-      H6.new(self, *args)
-    end
-    
-    def h1s
-      assert_exists
-      H1s.new(self)
-    end
-    
-    def h2s
-      assert_exists
-      H2s.new(self)
-    end
-    
-    def h3s
-      assert_exists
-      H3s.new(self)
-    end
-    
-    def h4s
-      assert_exists
-      H4s.new(self)
-    end
-    
-    def h5s
-      assert_exists
-      H5s.new(self)
-    end
-    
-    def h6s
-      assert_exists
-      H6s.new(self)
-    end
-
-    private
-
-    def matches?(string, what)
-      Regexp === what ? string.match(what) : string == what.to_s
-    end
-    
-  end # Container
-end # Celerity
+module Celerity
+  
+  #
+  # This class contains methods for accessing elements inside a container,
+  # usually the Browser object, meaning the current page.
+  # The most common syntax is
+  #   browser.elem(:attribute, 'value')
+  #
+  # Note that the element is located lazily, so no exceptions will be raised
+  # if the element doesn't exist until you call a method on the resulting object.
+  # To do this you would normally use Element#exists? or an action method,
+  # like ClickableElement#click.
+  # You can also pass in a hash:
+  #
+  #   browser.link(:index => 1).click
+  #
+  # All elements support multiple attributes identification using the
+  # hash syntax (though this might not always be compatible with Watir):
+  #
+  #   browser.span(:class_name => 'product', :index => 5).text
+  #
+  # Checkboxes and radio buttons support a special three-argument syntax:
+  #
+  #   browser.check_box(:name, 'a_name', '1234').set
+  #
+  # You can also get all the elements of a certain type by using the plural form (@see Celerity::ElementCollection):
+  #
+  #   browser.links # => #<Celerity::Links:0x7a1c2da2 ...>
+  #
+
+  module Container
+    include Celerity::Exception
+
+    # Points back to the Browser instance that contains this element
+    attr_reader :browser
+
+    #
+    # Check if the element contains the given text.
+    #
+    # @param  [String, Regexp] expected_text The text to look for.
+    # @return [Fixnum, nil]  The index of the matched text, or nil if it doesn't match.
+    # 
+    
+    def contains_text(expected_text)
+      assert_exists
+      return nil unless respond_to? :text
+
+      case expected_text
+      when Regexp
+        text() =~ expected_text
+      when String
+        text().index(expected_text)
+      else
+        raise TypeError, "expected String or Regexp, got #{expected_text.inspect}:#{expected_text.class}"
+      end
+    end
+    
+    #
+    # Used internally to update the container object.
+    # @api private
+    #
+    
+    def container=(container)
+      @container = container
+      @browser = container.browser
+      container
+    end
+
+    #
+    # Used internally to update the page object.
+    # @api private
+    #
+    
+    def update_page(page)
+      @browser.page = page
+    end
+    
+    #
+    # Used internally.
+    #
+    # @param [String] string The string to match against.
+    # @param [Regexp, String, #to_s] what The match we're looking for.
+    # @return [Fixnum, true, false, nil]
+    #
+    # @api private
+    #
+    
+    def matches?(string, what)
+      Regexp === what ? string =~ what : string == what.to_s
+    end
+
+    #--
+    # below methods sorted alphabetically
+    #++
+
+    #
+    # @return [Celerity::Area]
+    #
+    
+    def area(*args)
+      Area.new(self, *args)
+    end
+    
+    #
+    # @return [Celerity::Areas]
+    #
+    
+    def areas
+      Areas.new(self)
+    end
+    
+    #
+    # @return [Celerity::Button]
+    #
+    
+    def button(*args)
+      Button.new(self, *args)
+    end
+
+    #
+    # @return [Celerity::Buttons]
+    #
+    
+    def buttons
+      Buttons.new(self)
+    end
+    
+    #
+    # @return [Celerity::TableCell]
+    #
+    
+    def cell(*args)
+      TableCell.new(self, *args)
+    end
+    
+    #
+    # @return [Celerity::TableCells]
+    #
+    
+    def cells
+      TableCells.new(self)
+    end
+
+    #
+    # Since finding checkboxes by value is very common, you can use this shorthand:
+    #
+    #   browser.check_box(:name, 'a_name', '1234').set
+    #
+    # or
+    #
+    #   browser.check_box(:name => 'a_name', :value => '1234').set
+    #
+    # @return [Celerity::CheckBox]
+    #
+
+    def check_box(*args)
+      CheckBox.new(self, *args)
+    end
+
+    #
+    # @return [Celerity::CheckBoxes]
+    #
+
+    def checkboxes
+      CheckBoxes.new(self)
+    end
+
+    #
+    # @return [Celerity::Dd]
+    #
+
+    def dd(*args)
+      Dd.new(self, *args)
+    end
+    
+    #
+    # @return [Celerity::Dds]
+    #
+
+    def dds
+      Dds.new(self)
+    end
+    
+    #
+    # @return [Celerity::Div]
+    #
+
+    def div(*args)
+      Div.new(self, *args)
+    end
+    
+    #
+    # @return [Celerity::Divs]
+    #
+
+    def divs
+      Divs.new(self)
+    end
+    
+    #
+    # @return [Celerity::Dl]
+    #
+
+    def dl(*args)
+      Dl.new(self, *args)
+    end
+
+    #
+    # @return [Celerity::Dls]
+    #
+
+    def dls
+      Dls.new(self)
+    end
+    
+    #
+    # @return [Celerity::Dt]
+    #
+
+    def dt(*args)
+      Dt.new(self, *args)
+    end
+
+    #
+    # @return [Celerity::Dts]
+    #
+
+    def dts
+      Dts.new(self)
+    end
+    
+    #
+    # @return [Celerity::Em]
+    # 
+    
+    def em(*args)
+      Em.new(self, *args)
+    end
+    
+    #
+    # @return [Celerity::Ems]
+    # 
+    
+    def ems
+      Ems.new(self)
+    end
+
+    #
+    # @return [Celerity::FileField]
+    #
+
+    def file_field(*args)
+      FileField.new(self, *args)
+    end
+
+    #
+    # @return [Celerity::FileFields]
+    #
+
+    def file_fields
+      FileFields.new(self)
+    end
+
+    #
+    # @return [Celerity::Form]
+    #
+
+    def form(*args)
+      Form.new(self, *args)
+    end
+
+    #
+    # @return [Celerity::Forms]
+    #
+
+    def forms
+      Forms.new(self)
+    end
+
+    #
+    # @return [Celerity::Frame]
+    #
+
+    def frame(*args)
+      Frame.new(self, *args)
+    end
+    
+    #
+    # @return [Celerity::Frames]
+    #
+
+    def frames
+      Frames.new(self)
+    end
+
+    #
+    # @return [Celerity::H1]
+    #
+
+    def h1(*args)
+      H1.new(self, *args)
+    end
+    
+    #
+    # @return [Celerity::H1s]
+    #
+
+    def h1s
+      H1s.new(self)
+    end
+
+    #
+    # @return [Celerity::H2]
+    #
+
+    def h2(*args)
+      H2.new(self, *args)
+    end
+
+    #
+    # @return [Celerity::H2s]
+    #
+
+    def h2s
+      H2s.new(self)
+    end
+
+    #
+    # @return [Celerity::H3]
+    #
+
+    def h3(*args)
+      H3.new(self, *args)
+    end
+
+    #
+    # @return [Celerity::H3s]
+    #
+
+    def h3s
+      H3s.new(self)
+    end
+    
+    #
+    # @return [Celerity::H4]
+    #
+
+    def h4(*args)
+      H4.new(self, *args)
+    end
+
+    #
+    # @return [Celerity::H4s]
+    #
+
+    def h4s
+      H4s.new(self)
+    end
+    
+    #
+    # @return [Celerity::H5]
+    #
+
+    def h5(*args)
+      H5.new(self, *args)
+    end
+
+    #
+    # @return [Celerity::H5s]
+    #
+
+    def h5s
+      H5s.new(self)
+    end
+    
+    #
+    # @return [Celerity::H6]
+    #
+
+    def h6(*args)
+      H6.new(self, *args)
+    end
+
+    #
+    # @return [Celerity::H6s]
+    #
+
+    def h6s
+      H6s.new(self)
+    end
+
+    #
+    # @return [Celerity::Hidden]
+    #
+
+    def hidden(*args)
+      Hidden.new(self, *args)
+    end
+
+    #
+    # @return [Celerity::Hiddens]
+    #
+
+    def hiddens
+      Hiddens.new(self)
+    end
+
+    #
+    # @return [Celerity::Image]
+    #
+
+    def image(*args)
+      Image.new(self, *args)
+    end
+
+    #
+    # @return [Celerity::Images]
+    #
+
+    def images
+      Images.new(self)
+    end
+
+    #
+    # @return [Celerity::Label]
+    #
+
+    def label(*args)
+      Label.new(self, *args)
+    end
+
+    #
+    # @return [Celerity::Labels]
+    #
+
+    def labels
+      Labels.new(self)
+    end
+
+    #
+    # @return [Celerity::Li]
+    #
+
+    def li(*args)
+      Li.new(self, *args)
+    end
+
+    #
+    # @return [Celerity::Lis]
+    #
+
+    def lis
+      Lis.new(self)
+    end
+
+    #
+    # @return [Celerity::Link]
+    #
+
+    def link(*args)
+      Link.new(self, *args)
+    end
+
+    #
+    # @return [Celerity::Links]
+    #
+
+    def links
+      Links.new(self)
+    end
+
+    #
+    # @return [Celerity::Map]
+    #
+
+    def map(*args)
+      Map.new(self, *args)
+    end
+
+    #
+    # @return [Celerity::Maps]
+    #
+
+    def maps
+      Maps.new(self)
+    end
+
+    #
+    # @return [Celerity::Meta]
+    #
+
+    def meta(*args)
+      Meta.new(self, *args)
+    end
+
+    #
+    # @return [Celerity::Metas]
+    #
+
+    def metas(*args)
+      Metas.new(self, *args)
+    end
+
+    #
+    # @return [Celerity::Ol]
+    #
+
+    def ol(*args)
+      Ol.new(self, *args)
+    end
+
+    #
+    # @return [Celerity::Ols]
+    #
+
+    def ols
+      Ols.new(self)
+    end
+
+    #
+    # @return [Celerity::Option]
+    #
+
+    def option(*args)
+      Option.new(self, *args)
+    end
+
+    #
+    # @return [Celerity::P]
+    #
+
+    def p(*args)
+      P.new(self, *args)
+    end
+
+    #
+    # @return [Celerity::Ps]
+    #
+
+    def ps
+      Ps.new(self)
+    end
+
+    #
+    # @return [Celerity::Pre]
+    #
+
+    def pre(*args)
+      Pre.new(self, *args)
+    end
+
+    #
+    # @return [Celerity::Pres]
+    #
+
+    def pres
+      Pres.new(self)
+    end
+
+    #
+    # Since finding radios by value is very common, you can use this shorthand:
+    #
+    #   browser.radio(:name, 'a_name', '1234').set
+    #
+    # or
+    #
+    #   browser.radio(:name => 'a_name', :value => '1234').set
+    #
+    # @return [Celerity::Radio]
+    #
+    
+    def radio(*args)
+      Radio.new(self, *args)
+    end
+
+    #
+    # @return [Celerity::Radios]
+    #
+
+    def radios
+      Radios.new(self)
+    end
+
+    #
+    # @return [Celerity::TableRow]
+    #
+
+    def row(*args)
+      TableRow.new(self, *args)
+    end
+
+    #
+    # @return [Celerity::TableRows]
+    #
+
+    def rows
+      TableRows.new(self)
+    end
+
+    #
+    # @return [Celerity::SelectList]
+    #
+
+    def select_list(*args)
+      SelectList.new(self, *args)
+    end
+
+    #
+    # @return [Celerity::SelectLists]
+    #
+
+    def select_lists
+      SelectLists.new(self)
+    end
+    
+    #
+    # @return [Celerity::Span]
+    #
+
+    def span(*args)
+      Span.new(self, *args)
+    end
+
+    #
+    # @return [Celerity::Spans]
+    #
+
+    def spans
+      Spans.new(self)
+    end
+
+    #
+    # @return [Celerity::Spans]
+    #
+
+    def strong(*args)
+      Strong.new(self, *args)
+    end
+
+    #
+    # @return [Celerity::Strongs]
+    #
+
+    def strongs
+      Strongs.new(self)
+    end
+
+    #
+    # @return [Celerity::Table]
+    #
+
+    def table(*args)
+      Table.new(self, *args)
+    end
+
+    #
+    # @return [Celerity::Tables]
+    #
+
+    def tables
+      Tables.new(self)
+    end
+
+    #
+    # @return [Celerity::TableBody]
+    #
+
+    def tbody(*args)
+      TableBody.new(self, *args)
+    end
+
+    #
+    # @return [Celerity::TableBodies]
+    #
+
+    def tbodies
+      TableBodies.new(self)
+    end
+    
+    #
+    # @return [Celerity::TextField]
+    #
+
+    def text_field(*args)
+      TextField.new(self, *args)
+    end
+
+    #
+    # @return [Celerity::TextFields]
+    #
+
+    def text_fields
+      TextFields.new(self)
+    end
+    
+    #
+    # @return [Celerity::TableFooter]
+    #
+
+    def tfoot(*args)
+      TableFooter.new(self, *args)
+    end
+
+    #
+    # @return [Celerity::TableFooters]
+    #
+
+    def tfoots
+      TableFooters.new(self)
+    end
+    alias_method :tfeet, :tfoots # :-)
+    
+    #
+    # Watir's cells() won't find <th> elements.
+    # This is a workaround.
+    #
+    # @return [Celerity::Th]
+    #
+    
+    def th(*args)
+      Th.new(self, *args)
+    end
+
+    #
+    # FIXME: implement or change api,
+    # @see th
+    #
+
+    def ths
+      raise NotImplementedError
+    end
+    
+    #
+    # @return [Celerity::TableHeader]
+    #
+
+    def thead(*args)
+      TableHeader.new(self, *args)
+    end
+
+    #
+    # @return [Celerity::TableHeaders]
+    #
+
+    def theads
+      TableHeaders.new(self)
+    end
+
+    #
+    # @return [Celerity::Ul]
+    #
+
+    def ul(*args)
+      Ul.new(self, *args)
+    end
+
+    #
+    # @return [Celerity::Uls]
+    #
+
+    def uls
+      Uls.new(self)
+    end
+
+  end # Container
+end # Celerity