druid-ts 1.1.6 → 1.1.7

data/features/step_definations/multi_elements_steps.rb

@@ -1,5 +1,35 @@
 class MultiElementsPage
   include Druid
+
+  divs(:the_divs, :class => 'div')
+  buttons(:the_buttons, :class => 'button')
+  text_fields(:the_text_fields, :class => 'textfield')
+  hidden_fields(:the_hidden_fields, :class => 'hiddenfield')
+  text_areas(:the_text_areas, :class => 'textarea')
+  select_lists(:the_select_lists, :class => 'selectlist')
+  links(:the_links, :class => 'link')
+  checkboxes(:the_checkboxes, :class => 'checkbox')
+  radio_buttons(:the_radio_buttons, :class => 'radio')
+  spans(:the_spans, :class => 'span')
+  tables(:the_tables, :class => 'table')
+  cells(:the_cells, :class => 'td')
+  images(:the_images, :class => 'image')
+  forms(:the_forms, :class => 'form')
+  list_items(:the_list_items, :class => 'li')
+  unordered_lists(:the_unordered_lists, :class => 'ul')
+  ordered_lists(:the_ordered_lists, :class => 'ol')
+  h1s(:the_h1s, :class => 'h1')
+  h2s(:the_h2s, :class => 'h2')
+  h3s(:the_h3s, :class => 'h3')
+  h4s(:the_h4s, :class => 'h4')
+  h5s(:the_h5s, :class => 'h5')
+  h6s(:the_h6s, :class => 'h6')
+  paragraphs(:the_paragraphs, :class => 'p')
+  labels(:the_labels, :class => 'label')
+  file_fields(:the_file_fields, :class => 'file_field_class')
+  divs(:block_divs) do |page|
+    page.div_elements(:class => 'div')
+  end
 end
 
 Given(/^I am on the multi elements page$/) do
@@ -402,3 +432,91 @@ end
 When(/^I select all file fields using no identifier$/) do
   @elements = @page.file_field_elements
 end
+
+When(/^I select the divs using the generated method$/) do
+  @elements = @page.the_divs_elements
+end
+
+When(/^I select the buttons using the generated method$/) do
+  @elements = @page.the_buttons_elements
+end
+
+When(/^I select the text field using the generated method$/) do
+  @elements = @page.the_text_fields_elements
+end
+
+When(/^I select the hidden fields using the generated method$/) do
+  @elements = @page.the_hidden_fields_elements
+end
+
+When(/^I select the text areas using the generated method$/) do
+  @elements = @page.the_text_areas_elements
+end
+
+When(/^I select the select lists using the generated method$/) do
+  @elements = @page.the_select_lists_elements
+end
+
+When(/^I select the links using the generated method$/) do
+  @elements = @page.the_links_elements
+end
+
+When(/^I select the check boxes using the generated method$/) do
+  @elements = @page.the_checkboxes_elements
+end
+
+When(/^I select the radio buttons using the generated method$/) do
+  @elements = @page.the_radio_buttons_elements
+end
+
+When(/^I select the spans using the generated method$/) do
+  @elements = @page.the_spans_elements
+end
+
+When(/^I select the tables using the generated method$/) do
+  @elements = @page.the_tables_elements
+end
+
+When(/^I select the cells using the generated method$/) do
+  @elements = @page.the_cells_elements
+end
+
+When(/^I select the images using the generated method$/) do
+  @elements = @page.the_images_elements
+end
+
+When(/^I select the forms using the generated method$/) do
+  @elements = @page.the_forms_elements
+end
+
+When(/^I select the list items using the generated method$/) do
+  @elements = @page.the_list_items_elements
+end
+
+When(/^I select the unordered lists using the generated method$/) do
+  @elements = @page.the_unordered_lists_elements
+end
+
+When(/^I select the ordered lists using the generated method$/) do
+  @elements = @page.the_ordered_lists_elements
+end
+
+When(/^I select the h(\d+)s using the generated method$/) do |num|
+  @elements = @page.send("the_h#{num.to_i}s_elements")
+end
+
+When(/^I select the paragraphs using the generated method$/) do
+  @elements = @page.the_paragraphs_elements
+end
+
+When(/^I select the labels using the generated method$/) do
+  @elements = @page.the_labels_elements
+end
+
+When(/^I select the file fields using the generated method$/) do
+  @elements = @page.the_file_fields_elements
+end
+
+When(/^I select the divs using a block$/) do
+  @elements = @page.block_divs_elements
+end

data/features/support/persistent_browser.rb

@@ -1,10 +1,19 @@
+require 'selenium/webdriver/remote/http/persistent'
+
 module Druid
   module PersistantBrowser
     @@driver = false
     def self.get_browser
       if !@@driver
-        target_browser = ENV['BROWSER'].to_sym
-        @@driver = Watir::Browser.new target_browser if ENV['DRIVER'] == 'WATIR'
+        target = ENV['BROWSER']
+        target = 'firefox_local' unless target
+
+        if is_remote?(target)
+          require File.dirname(__FILE__) + "/targets/#{target}"
+          extend Target
+        end
+
+        @@driver = watir_browser(target) if ENV['DRIVER'] == 'WATIR'
       end
       @@driver
     end
@@ -12,5 +21,38 @@ module Druid
     def self.quit
       @@driver.quit
     end
+
+    private
+
+    def self.is_remote?(target)
+      not target.include? 'local'
+    end
+
+    def self.watir_browser(target)
+      if is_remote?(target)
+        Watir::Browser.new(:remote,
+                           :http_client => client,
+                           :url => url,
+                           :desired_capabilities => desired_capabilities )
+      else
+        Watir::Browser.new :firefox
+      end
+    end
+
+    def self.client
+      Selenium::WebDriver::Remote::Http::Persistent.new
+    end
+
+    def self.capabilities(browser, version, platform, name)
+      caps = Selenium::WebDriver::Remote::Capabilities.send browser
+      caps.version = version
+      caps.platform = platform
+      caps[:name] = name
+      caps
+    end
+
+    def self.url
+      "http://pageobject:18002ee8-963b-472e-9425-2baf0a2b6d95@ondemand.saucelabs.com:80/wd/hub"
+    end
   end
 end

data/features/support/targets/firefox14_osx.rb

@@ -0,0 +1,5 @@
+module Target
+  def desired_capabilities
+    capabilities(:firefox, '14', 'Mac 10.6', 'Testing page-object with Firefox 14 on OS X')
+  end
+end

data/features/support/targets/firefox14_windows7.rb

@@ -0,0 +1,5 @@
+module Target
+  def desired_capabilities
+    capabilities(:firefox, '14', 'Windows 2008', 'Testing page-object with Firefox 15 on Windows 7')
+  end
+end

data/features/support/url_helper.rb

@@ -5,7 +5,9 @@ module UrlHelper
     end
 
     def files
-      "file://#{html}"
+      target = ENV['BROWSER']
+      return "file://#{html}" if target.nil? or target.include? 'local'
+      'http://ec2-107-22-131-88.compute-1.amazonaws.com'
     end
 
     def static_elements

data/features/video.feature

@@ -1,54 +1,54 @@
-#Feature: Support for video element
-
-  #Background:
-    #Given I am on the static elements page
-
-  #Scenario: Finding an video element
-    #When I retrieve the video element
-    #Then I should know it exists
-    #And I should know it is visible
-
-  #Scenario Outline: Locating a video element on the page
-    #When I search for the video element by "<search_by>"
-    #Then I should know it is visible
-
-    #Examples:
-      #| search_by |
-      #| id        |
-      #| class     |
-      #| name      |
-      #| xpath     |
-      #| index     |
-
-   #Scenario Outline: Locating videos using multiple parameters
-    #When I search for the video element by "<param1>" and "<param2>"
-     #Then I should know it is visible
-
-     #Examples:
-      # | param1  | param2  |
-       #| class   | index   |
-       #| name    | index   |
-
-   #Scenario Outline: Locating videos using multiple parameters
-    #When I search for the video element by "<param1>" and "<param2>"
-    #Then I should know it is visible
-
-    #Examples:
-    #| param1 | param2 |
-    #| class  | index  |
-    #| name   | index  |
-
-  #Scenario: Should know if it is autoplay
-  #  When I retrieve the video element
-  #  Then I should know the video is not autoplay
-
-  #Scenario: Should know if the controls are displayed
-  #  When I retrieve the video element
-  #  Then I should know that the controls are displayed
-
-  #Scenario: Should know if it is paused
-  #  When I retrieve the video element
-  #  Then I should know that the video is paused
+Feature: Support for video element
+
+  Background:
+    Given I am on the static elements page
+
+  Scenario: Finding an video element
+    When I retrieve the video element
+    Then I should know it exists
+    And I should know it is visible
+
+  Scenario Outline: Locating a video element on the page
+    When I search for the video element by "<search_by>"
+    Then I should know it is visible
+
+    Examples:
+      | search_by |
+      | id        |
+      | class     |
+      | name      |
+      | xpath     |
+      | index     |
+
+   Scenario Outline: Locating videos using multiple parameters
+     When I search for the video element by "<param1>" and "<param2>"
+     Then I should know it is visible
+
+     Examples:
+       | param1  | param2  |
+       | class   | index   |
+       | name    | index   |
+
+   Scenario Outline: Locating videos using multiple parameters
+     When I search for the video element by "<param1>" and "<param2>"
+     Then I should know it is visible
+
+    Examples:
+    | param1 | param2 |
+    | class  | index  |
+    | name   | index  |
+
+  Scenario: Should know if it is autoplay
+    When I retrieve the video element
+    Then I should know the video is not autoplay
+
+  Scenario: Should know if the controls are displayed
+    When I retrieve the video element
+    Then I should know that the controls are displayed
+
+  Scenario: Should know if it is paused
+    When I retrieve the video element
+    Then I should know that the video is paused
 
   #Scenario: Should know its duration
   #  When I retrieve the video element

data/lib/druid/accessors.rb

@@ -58,8 +58,9 @@ module Druid
     #
     def expected_title(expected_title)
       define_method("has_expected_title?") do
-        has_expected_title = expected_title === title
-        raise "Expected title '#{expected_title}' instead of '#{title}'" unless has_expected_title
+        page_title = title
+        has_expected_title = (expected_title === page_title)
+        raise "Expected title '#{expected_title}' instead of '#{page_title}'" unless has_expected_title
         has_expected_title
       end
     end
@@ -75,7 +76,7 @@ module Druid
     #   expected_element(:address, 10)
     #   page.has_expected_element?
     #
-    def expected_element(element_name, timeout=5)
+    def expected_element(element_name, timeout=Druid.default_element_wait)
       define_method("has_expected_element?") do
         self.respond_to? "#{element_name}_element" and self.send("#{element_name}_element").when_present timeout
       end
@@ -156,16 +157,7 @@ module Druid
         return click_link_for identifier.clone unless block_given?
         self.send("#{name}_element").click
       end
-      define_method("#{name}_element") do
-        return call_block(&block) if block_given?
-        link_for(identifier.clone)
-        # block ? call_block(&block) : link_for(identifier.clone)
-      end
-      define_method("#{name}?") do
-        return call_block(&block).exist? if block_given?
-        link_for(identifier.clone).exist?
-      end
-      alias_method "#{name}_link".to_sym, "#{name}_element".to_sym
+      standard_methods(name, identifier, 'link_for', &block)
     end
 
     alias_method :a, :link
@@ -203,16 +195,7 @@ module Druid
         return text_field_value_set(identifier.clone, value) unless block_given?
         self.send("#{name}_element").value = value
       end
-      define_method("#{name}_element") do
-        return call_block(&block) if block_given?
-        text_field_for(identifier.clone)
-        # block ? call_block(&block) : text_field_for(identifier.clone)
-      end
-      define_method("#{name}?") do
-        return call_block(&block).exist? if block_given?
-        text_field_for(identifier.clone).exist?
-      end
-      alias_method "#{name}_text_field".to_sym, "#{name}_element".to_sym
+      standard_methods(name, identifier, 'text_field_for', &block)
     end
 
     #
@@ -250,27 +233,19 @@ module Druid
         return checkbox_checked? identifier.clone unless block_given?
         self.send("#{name}_element").checked?
       end
-      define_method("#{name}_element") do
-        return call_block(&block) if block_given?
-        checkbox_for(identifier.clone)
-        # block ? call_block(&block) : checkbox_for(identifier.clone)
-      end
-      define_method("#{name}?") do
-        return call_block(&block).exist? if block_given?
-        checkbox_for(identifier.clone).exist?
-      end
-      alias_method "#{name}_checkbox".to_sym, "#{name}_element".to_sym
+      standard_methods(name, identifier, 'checkbox_for', &block)
     end
 
     #
-    # adds four methods - one to select an item in a drop-down,
+    # adds five methods - one to select an item in a drop-down,
     # another to fetch the currently selected item text, another
     # to retrieve the select list element, and another to check the
-    # drop down's existence.
+    # drop down's existence and another to get all the available options
+    # to select from
     #
     # @example
     #   select_list(:state, :id => "state")
-    #   # will generate 'state', 'state=', 'state_element', 'state?' methods
+    #   # will generate 'state', 'state=', 'state_element', 'state?', 'state_options' methods
     #
     # @param [Symbol] the name used for the generated methods
     # @param [Hash] identifier how we find a select_list.  You can use a multiple parameters
@@ -291,16 +266,11 @@ module Druid
         return select_list_value_set(identifier.clone, value) unless block_given?
         self.send("#{name}_element").select(value)
       end
-      define_method("#{name}_element") do
-        return call_block(&block) if block_given?
-        select_list_for(identifier.clone)
-        # block ? call_block(&block) : select_list_for(identifier.clone)
-      end
-      define_method("#{name}?") do
-        return call_block(&block).exist? if block_given?
-        select_list_for(identifier.clone).exist?
+      define_method("#{name}_options") do
+        element = self.send("#{name}_element")
+        (element && element.options) ? element.options.collect(&:text) : []
       end
-      alias_method "#{name}_select_list".to_sym, "#{name}_element".to_sym
+      standard_methods(name, identifier, 'select_list_for', &block)
     end
     alias_method :select, :select_list
 
@@ -340,16 +310,7 @@ module Druid
         return radio_selected? identifier.clone unless block_given?
         self.send("#{name}_element").selected?
       end
-      define_method("#{name}_element") do
-        return call_block(&block) if block_given?
-        radio_button_for(identifier.clone)
-        # block ? call_block(&block) : radio_button_for(identifier.clone)
-      end
-      define_method("#{name}?") do
-        return call_block(&block).exist? if block_given?
-        radio_button_for(identifier.clone).exist?
-      end
-      alias_method "#{name}_radio_button".to_sym, "#{name}_element".to_sym
+      standard_methods(name, identifier, 'radio_button_for', &block)
     end
     alias_method :radio, :radio_button
 
@@ -380,16 +341,7 @@ module Druid
         return click_button_for identifier.clone unless block_given?
         self.send("#{name}_element").click
       end
-      define_method("#{name}_element") do
-        return call_block(&block) if block_given?
-        button_for(identifier.clone)
-        # block ? call_block(&block) : button_for(identifier.clone)
-      end
-      define_method("#{name}?") do
-        return call_block(&block).exist? if block_given?
-        button_for(identifier.clone).exist?
-      end
-      alias_method "#{name}_button".to_sym, "#{name}_element".to_sym
+      standard_methods(name, identifier, 'button_for', &block)
     end
 
     #
@@ -418,16 +370,7 @@ module Druid
         return div_text_for identifier.clone unless block_given?
         self.send("#{name}_element").text
       end
-      define_method("#{name}_element") do
-        return call_block(&block) if block_given?
-        div_for(identifier.clone)
-        # block ? call_block(&block) : div_for(identifier.clone)
-      end
-      define_method("#{name}?") do
-        return call_block(&block).exist? if block_given?
-        div_for(identifier.clone).exist?
-      end
-      alias_method "#{name}_div".to_sym, "#{name}_element".to_sym
+      standard_methods(name, identifier, 'div_for', &block)
     end
 
     #
@@ -454,16 +397,7 @@ module Druid
         return table_text_for identifier.clone unless block_given?
         self.send("#{name}_element").text
       end
-      define_method("#{name}_element") do
-        return call_block(&block) if block_given?
-        table_for(identifier.clone)
-        # block ? call_block(&block) : table_for(identifier.clone)
-      end
-      define_method("#{name}?") do
-        return call_block(&block).exist? if block_given?
-        table_for(identifier.clone).exist?
-      end
-      alias_method "#{name}_table".to_sym, "#{name}_element".to_sym
+      standard_methods(name, identifier, 'table_for', &block)
     end
 
     #
@@ -491,16 +425,7 @@ module Druid
         return cell_text_for identifier.clone unless block_given?
         self.send("#{name}_element").text
       end
-      define_method("#{name}_element") do
-        return call_block(&block) if block_given?
-        cell_for(identifier.clone)
-        # block ? call_block(&block) : cell_for(identifier.clone)
-      end
-      define_method("#{name}?") do
-        return call_block(&block).exist? if block_given?
-        cell_for(identifier.clone).exist?
-      end
-      alias_method "#{name}_cell".to_sym, "#{name}_element".to_sym
+      standard_methods(name, identifier, 'cell_for', &block)
     end
     alias_method :td, :cell
 
@@ -529,16 +454,7 @@ module Druid
         return span_text_for identifier.clone unless block_given?
         self.send("#{name}_element").text
       end
-      define_method("#{name}_element") do
-        return call_block(&block) if block_given?
-        span_for(identifier.clone)
-        # block ? call_block(&block) : span_for(identifier.clone)
-      end
-      define_method("#{name}?") do
-        return call_block(&block).exist? if block_given?
-        span_for(identifier.clone).exist?
-      end
-      alias_method "#{name}_span".to_sym, "#{name}_element".to_sym
+      standard_methods(name, identifier, 'span_for', &block)
     end
 
     #
@@ -562,16 +478,7 @@ module Druid
     # @param optional block to be invoked when element method is called
     #
     def image(name, identifier={:index => 0}, &block)
-      define_method("#{name}_element") do
-        return call_block(&block) if block_given?
-        image_for(identifier.clone)
-        # block ? call_block(&block) : image_for(identifier.clone)
-      end
-      define_method("#{name}?") do
-        return call_block(&block).exist? if block_given?
-        image_for(identifier.clone).exist?
-      end
-      alias_method "#{name}_image".to_sym, "#{name}_element".to_sym
+      standard_methods(name, identifier, 'image_for', &block)
     end
     alias_method :img, :image
 
@@ -595,16 +502,7 @@ module Druid
     # @param optional block to be invoked when element method is called
     #
     def form(name, identifier={:index => 0}, &block)
-      define_method("#{name}_element") do
-        return call_block(&block) if block_given?
-        form_for(identifier.clone)
-        # block ? call_block(&block) : form_for(identifier.clone)
-      end
-      define_method("#{name}?") do
-        return call_block(&block).exist? if block_given?
-        form_for(identifier.clone).exist?
-      end
-      alias_method "#{name}_form".to_sym, "#{name}_element".to_sym
+      standard_methods(name, identifier, 'form_for', &block)
     end
 
     #
@@ -629,20 +527,11 @@ module Druid
     # @param optional block to be invoked when element method is called
     #
     def hidden_field(name, identifier={:index => 0}, &block)
-      define_method("#{name}_element") do
-        return call_block(&block) if block_given?
-        hidden_field_for(identifier.clone)
-        # block ? call_block(&block) : hidden_field_for(identifier.clone)
-      end
       define_method(name) do
         return hidden_field_value_for identifier.clone unless block_given?
         self.send("#{name}_element").value
       end
-      define_method("#{name}?") do
-        return call_block(&block).exist? if block_given?
-        hidden_field_for(identifier.clone).exist?
-      end
-      alias_method "#{name}_hidden_field".to_sym, "#{name}_element".to_sym
+      standard_methods(name, identifier, 'hidden_field_for', &block)
     end
     alias_method :hidden, :hidden_field
 
@@ -671,16 +560,7 @@ module Druid
         return list_item_text_for identifier.clone unless block_given?
         self.send("#{name}_element").text
       end
-      define_method("#{name}_element") do
-        return call_block(&block) if block_given?
-        list_item_for(identifier.clone)
-        # block ? call_block(&block) : list_item_for(identifier.clone)
-      end
-      define_method("#{name}?") do
-        return call_block(&block).exist? if block_given?
-        list_item_for(identifier.clone).exist?
-      end
-      alias_method "#{name}_list_item".to_sym, "#{name}_element".to_sym
+      standard_methods(name, identifier, 'list_item_for', &block)
     end
     alias_method :li, :list_item
 
@@ -708,16 +588,7 @@ module Druid
         return ordered_list_text_for identifier.clone unless block_given?
         self.send("#{name}_element").text
       end
-      define_method("#{name}_element") do
-        return call_block(&block) if block_given?
-        ordered_list_for(identifier.clone)
-        # block ? call_block(&block) : ordered_list_for(identifier.clone)
-      end
-      define_method("#{name}?") do
-        return call_block(&block).exist? if block_given?
-        ordered_list_for(identifier.clone).exist?
-      end
-      alias_method "#{name}_ordered_list".to_sym, "#{name}_element".to_sym
+      standard_methods(name, identifier, 'ordered_list_for', &block)
     end
     alias_method :ol, :ordered_list
 
@@ -750,16 +621,7 @@ module Druid
         return text_area_value_for identifier.clone unless block_given?
         self.send("#{name}_element").value
       end
-      define_method("#{name}_element") do
-        return call_block(&block) if block_given?
-        text_area_for(identifier.clone)
-        # block ? call_block(&block) : text_area_for(identifier.clone)
-      end
-      define_method("#{name}?") do
-        return call_block(&block).exist? if block_given?
-        text_area_for(identifier.clone).exist?
-      end
-      alias_method "#{name}_text_area".to_sym, "#{name}_element".to_sym
+      standard_methods(name, identifier, 'text_area_for', &block)
     end
     alias_method :textarea, :text_area
 
@@ -785,16 +647,7 @@ module Druid
         return unordered_list_text_for identifier.clone unless block_given?
         self.send("#{name}_element").text
       end
-      define_method("#{name}_element") do
-        return call_block(&block) if block_given?
-        unordered_list_for(identifier.clone)
-        # block ? call_block(&block) : unordered_list_for(identifier.clone)
-      end
-      define_method("#{name}?") do
-        return call_block(&block).exist? if block_given?
-        unordered_list_for(identifier.clone).exist?
-      end
-      alias_method "#{name}_unordered_list".to_sym, "#{name}_element".to_sym
+      standard_methods(name, identifier, 'unordered_list_for', &block)
     end
     alias_method :ul, :unordered_list
 
@@ -821,15 +674,7 @@ module Druid
         return h1_text_for identifier.clone unless block_given?
         self.send("#{name}_element").text
       end
-      define_method("#{name}_element") do
-        return call_block(&block) if block_given?
-        h1_for(identifier.clone)
-      end
-      define_method("#{name}?") do
-        return call_block(&block).exist? if block_given?
-        h1_for(identifier.clone).exist?
-      end
-      alias_method "#{name}_h1".to_sym, "#{name}_element".to_sym
+      standard_methods(name, identifier, 'h1_for', &block)
     end
 
     #
@@ -855,15 +700,7 @@ module Druid
         return h2_text_for identifier.clone unless block_given?
         self.send("#{name}_element").text
       end
-      define_method("#{name}_element") do
-        return call_block(&block) if block_given?
-        h2_for(identifier.clone)
-      end
-      define_method("#{name}?") do
-        return call_block(&block).exist? if block_given?
-        h2_for(identifier.clone).exist?
-      end
-      alias_method "#{name}_h2".to_sym, "#{name}_element".to_sym
+      standard_methods(name, identifier, 'h2_for', &block)
     end
 
     #
@@ -889,15 +726,7 @@ module Druid
         return h3_text_for identifier.clone unless block_given?
         self.send("#{name}_element").text
       end
-      define_method("#{name}_element") do
-        return call_block(&block) if block_given?
-        h3_for(identifier.clone)
-      end
-      define_method("#{name}?") do
-        return call_block(&block).exist? if block_given?
-        h3_for(identifier.clone).exist?
-      end
-      alias_method "#{name}_h3".to_sym, "#{name}_element".to_sym
+      standard_methods(name, identifier, 'h3_for', &block)
     end
 
     #
@@ -923,15 +752,7 @@ module Druid
         return h4_text_for identifier.clone unless block_given?
         self.send("#{name}_element").text
       end
-      define_method("#{name}_element") do
-        return call_block(&block) if block_given?
-        h4_for(identifier.clone)
-      end
-      define_method("#{name}?") do
-        return call_block(&block).exist? if block_given?
-        h4_for(identifier.clone).exist?
-      end
-      alias_method "#{name}_h4".to_sym, "#{name}_element".to_sym
+      standard_methods(name, identifier, 'h4_for', &block)
     end
 
     #
@@ -957,15 +778,7 @@ module Druid
         return h5_text_for identifier.clone unless block_given?
         self.send("#{name}_element").text
       end
-      define_method("#{name}_element") do
-        return call_block(&block) if block_given?
-        h5_for(identifier.clone)
-      end
-      define_method("#{name}?") do
-        return call_block(&block).exist? if block_given?
-        h5_for(identifier.clone).exist?
-      end
-      alias_method "#{name}_h5".to_sym, "#{name}_element".to_sym
+      standard_methods(name, identifier, 'h5_for', &block)
     end
 
     #
@@ -991,15 +804,7 @@ module Druid
         return h6_text_for identifier.clone unless block_given?
         self.send("#{name}_element").text
       end
-      define_method("#{name}_element") do
-        return call_block(&block) if block_given?
-        h6_for(identifier.clone)
-      end
-      define_method("#{name}?") do
-        return call_block(&block).exist? if block_given?
-        h6_for(identifier.clone).exist?
-      end
-      alias_method "#{name}_h6".to_sym, "#{name}_element".to_sym
+      standard_methods(name, identifier, 'h6_for', &block)
     end
 
     #
@@ -1025,15 +830,7 @@ module Druid
         return paragraph_text_for identifier.clone unless block_given?
         self.send("#{name}_element").text
       end
-      define_method("#{name}_element") do
-        return call_block(&block) if block_given?
-        paragraph_for(identifier.clone)
-      end
-      define_method("#{name}?") do
-        return call_block(&block).exist? if block_given?
-        paragraph_for(identifier.clone).exist?
-      end
-      alias_method "#{name}_paragraph".to_sym, "#{name}_element".to_sym
+      standard_methods(name, identifier, 'paragraph_for', &block)
     end
     alias_method :p, :paragraph
 
@@ -1061,14 +858,7 @@ module Druid
         return file_field_value_set(identifier.clone, value) unless block_given?
         self.send("#{name}_element").value = value
       end
-      define_method("#{name}_element") do
-        return call_block(&block) if block_given?
-        file_field_for(identifier.clone)
-      end
-      define_method("#{name}?") do
-        return call_block(&block).exist? if block_given?
-        file_field_for(identifier.clone).exist?
-      end
+      standard_methods(name, identifier, 'file_field_for', &block)
     end
 
     #
@@ -1095,15 +885,7 @@ module Druid
         return label_text_for identifier.clone unless block_given?
         self.send("#{name}_element").text
       end
-      define_method("#{name}_element") do
-        return call_block(&block) if block_given?
-        label_for(identifier.clone)
-      end
-      define_method("#{name}?") do
-        return call_block(&block).exist? if block_given?
-        label_for(identifier.clone).exist?
-      end
-      alias_method "#{name}_label".to_sym, "#{name}_element".to_sym
+      standard_methods(name, identifier, 'label_for', &block)
     end
 
     #
@@ -1130,14 +912,7 @@ module Druid
         return click_area_for identifier.clone unless block_given?
         self.send("#{name}_element").click
       end
-      define_method("#{name}_element") do
-        return call_block(&block) if block_given?
-        area_for(identifier.clone)
-      end
-      define_method("#{name}?") do
-        return call_block(&block).exist? if block_given?
-        area_for(identifier.clone).exist?
-      end
+      standard_methods(name, identifier, 'area_for', &block)
     end
 
     #
@@ -1159,14 +934,7 @@ module Druid
     # @param optional block to be invoked when element method is called
     #
     def canvas(name, identifier={:index => 0}, &block)
-      define_method("#{name}_element") do
-        return call_block(&block) if block_given?
-        canvas_for(identifier.clone)
-      end
-      define_method("#{name}?") do
-        return call_block(&block).exist? if block_given?
-        canvas_for(identifier.clone).exist?
-      end
+      standard_methods(name, identifier, 'canvas_for', &block)
     end
 
     #
@@ -1188,14 +956,7 @@ module Druid
     # @param optional block to be invoked when element method is called
     #
     def audio(name, identifier={:index => 0}, &block)
-      define_method("#{name}_element") do
-        return call_block(&block) if block_given?
-        audio_for(identifier.clone)
-      end
-      define_method("#{name}?") do
-        return call_block(&block).exist? if block_given?
-        audio_for(identifier.clone).exist?
-      end
+      standard_methods(name, identifier, 'audio_for', &block)
     end
 
     #
@@ -1217,14 +978,7 @@ module Druid
     # @param optional block to be invoked when element method is called
     #
     def video(name, identifier={:index => 0}, &block)
-      define_method("#{name}_element") do
-        return call_block(&block) if block_given?
-        video_for(identifier.clone)
-      end
-      define_method("#{name}?") do
-        return call_block(&block).exist? if block_given?
-        video_for(identifier.clone).exist?
-      end
+      standard_methods(name, identifier, 'video_for', &block)
     end
 
     #
@@ -1257,5 +1011,124 @@ module Druid
         self.send("#{name}_element").exist?
       end
     end
+
+    #
+   # methods to generate accessors for types that follow the same
+   # pattern as element
+   #
+   # @example
+   #   address(:home_address, :id => "home_address")
+   #   will generate 'home_address', 'home_address_element' and 'home_address?'
+   #
+   # @param [Symbol] the name used for the generated methods
+   # @param [Symbol] the name of the tag for the element
+   # @param [Hash] identifier how we find an element.  You can use a multiple paramaters
+   #   by combining of any of the following except xpath.  The valid keys are:
+   #   * :class
+   #   * :css
+   #   * :id
+   #   * :index
+   #   * :name
+   #   * :xpath
+   # @param optional block to be invoked when element method is called
+   #
+   [:abbr,
+    :address,
+    :article,
+    :aside,
+    :bdi,
+    :bdo,
+    :cite,
+    :code,
+    :dd,
+    :dfn,
+    :dt,
+    :em,
+    :figcaption,
+    :figure,
+    :footer,
+    :header,
+    :hgroup,
+    :kbd,
+    :mark,
+    :nav,
+    :noscript,
+    :rp,
+    :rt,
+    :ruby,
+    :samp,
+    :section,
+    :sub,
+    :summary,
+    :sup,
+    :var,
+    :wbr].each do |type|
+     define_method(type) do |name, *identifier, &block|
+       identifier = identifier[0] ? identifier[0] : {:index => 0}
+       element(name, type, identifier, &block)
+     end
+   end
+
+    def standard_methods(name, identifier, method, &block)
+      define_method("#{name}_element") do
+        return call_block(&block) if block_given?
+        self.send(method, identifier.clone)
+      end
+      define_method("#{name}?") do
+        return call_block(&block).exist? if block_given?
+        self.send(method, identifier.clone).exist?
+      end
+    end
+
+    #
+    # methods to fetch multiple elements of the same type
+    #
+    # adds a method to the page objec to retrun all of the matching elements
+    #
+    # @example
+    #   text_fields(:first_name, :id => "first_name")
+    #   # will generate 'first_name_elements'
+    #
+    # @param  [String] the name used for the generated methods
+    # @param [Hash] identifier how we find a text field.  You can use a multiple paramaters
+    #   by combining of any of the following except xpath.  The valid
+    #   keys are the same ones supported by the standard methods.
+    # @param optional block to be invoked when element method is called
+    #
+    [:text_fields,
+     :hidden_fields,
+     :text_areas,
+     :select_lists,
+     :links,
+     :checkboxes,
+     :radio_buttons,
+     :buttons,
+     :divs,
+     :spans,
+     :tables,
+     :cells,
+     :images,
+     :forms,
+     :list_items,
+     :unordered_lists,
+     :ordered_lists,
+     :h1s,
+     :h2s,
+     :h3s,
+     :h4s,
+     :h5s,
+     :h6s,
+     :paragraphs,
+     :labels,
+     :file_fields].each do |method_name|
+      define_method(method_name) do |name, *identifier, &block|
+        define_method("#{name}_elements") do
+          return call_block(&block) unless block.nil?
+          platform_method = (method_name == :checkboxes) ? 'checkboxs_for' : "#{method_name.to_s}_for"
+          self.send platform_method, identifier.first.clone
+        end
+      end
+    end
+
   end
 end