druid-ts 0.0.1 → 1.1.0

data/features/support/persistent_browser.rb

@@ -0,0 +1,15 @@
+module Druid
+  module PersistantBrowser
+    @@driver = false
+    def self.get_browser
+      if !@@driver
+        @@driver = Watir::Browser.new :firefox if ENV['DRIVER'] == 'WATIR'
+      end
+      @@driver
+    end
+
+    def self.quit
+      @@driver.quit
+    end
+  end
+end

data/features/support/url_helper.rb

@@ -8,9 +8,32 @@ module UrlHelper
       "file://#{html}"
     end
 
-
     def static_elements
       "#{files}/static_elements.html"
     end
+
+    def frame_elements
+      "#{files}/frames.html"
+    end
+
+    def iframe_elements
+      "#{files}/iframes.html"
+    end
+
+    def nested_frame_elements
+      "#{files}/nested_frames.html"
+    end
+
+    def nested_elements
+      "#{files}/nested_elements.html"
+    end
+
+    def modal
+      "#{files}/modal.html"
+    end
+
+    def async
+      "#{files}/async.html"
+    end
   end
 end

data/features/table.feature

@@ -31,6 +31,8 @@ Feature: Table
     And each row should contain "Data"
     And row "1" should have "2" columns
     And each column should contain "Data"
+    And the data for the first row should be "Data1" and "Data2"
+    And the data for the last row should be "Data3" and "Data4"
 
   @multi
   Scenario Outline: Locating table using multiple parameters
@@ -41,3 +43,8 @@ Feature: Table
     | param1  | param2  |
     | class   | index   |
     | name    | index   |
+
+  @locator
+  Scenario: Finding a table dynamically
+    When I retrieve a table element while the script is executing
+    Then the data for row "1" should be "Data1" and "Data2"

data/features/table_cell.feature

@@ -19,6 +19,7 @@ Feature: Table Cell
     | xpath     |
     | index     |
     | name      |
+    | text      |
 
   Scenario: Retrieve a cell from a table by id
     When I retrieve table cell
@@ -34,3 +35,8 @@ Feature: Table Cell
     | param1  | param2  |
     | class   | index   |
     | name    | index   |
+
+  @locator
+  Scenario: Finding a table cell dynamically
+    When I retrieve a table cell element while the script is executing
+    Then the cell data should be 'Data4'

data/features/text_area.feature

@@ -30,3 +30,14 @@ Feature: Text Area
     | param1  | param2  |
     | class   | index   |
     | name    | index   |
+
+  @locator
+  Scenario: Finding a text area dynamically
+    When I find a text area while the script is executing
+    Then I should be able to type "I found it" into the area element
+
+  Scenario: Clearing the text area
+    When I type "abcdefghijklmnop" into the text area
+    Then the text area should contain "abcdefghijklmnop"
+    When I clear the text area
+    Then the text area should contain ""

data/features/text_field.feature

@@ -24,7 +24,7 @@ Feature: Text Fields
     | tag_name  |
     | index     |
     | text      |
-    #| value     |
+    | title     |
 
   Scenario: Retrieve a text field
     When I retrieve a text field
@@ -40,3 +40,8 @@ Feature: Text Fields
     | param1  | param2  |
     | class   | index   |
     | name    | index   |
+
+  @locator
+  Scenario: Finding a text field dynamically
+    When I find a text field while the script is executing
+    Then I should be able to type "i found it" into the field element

data/features/unordered_list.feature

@@ -34,3 +34,9 @@ Feature: Unordered list
     | class   | index   |
     | name    | index   |
     | class   | name    |
+
+  @locator
+  Scenario: Finding a unordered list dynamically
+    When I search for the unordered list while the script is executing
+    And I get the first item from the list
+    Then the list items text should be "Item One"

data/lib/druid.rb

@@ -1,6 +1,11 @@
 require 'druid/accessors'
+require 'druid/assist'
 require 'druid/page_factory'
+require 'druid/core_ext/string'
+require 'druid/element_locators'
+require 'druid/page_populator'
 
+# require 'watir-webdriver/extensions/alerts'
 #
 # Module that when included adds functionality to a page object.  This module
 # will add numerous class and instance methods that you use to define and
@@ -30,16 +35,27 @@ require 'druid/page_factory'
 # @see Druid::Accessors to see what class level methods are added to this module at runtime.
 #
 module Druid
+  include Assist
+  include ElementLocators
+  include PagePopulator
+  # include Watir::AlertHelper
   # @return [Watir::Browser] the drvier passed to the constructor
   attr_reader :driver
   #
-  # Construct a new druid.
+  # Construct a new druid. Upon initialization of the page it will call a method named
+  # initialize_page if it exists
   #
   # @param [Watir::Browser] the driver to use
+  # @param [bool] open the page if page_url is set
   #
   def initialize(driver, visit=false)
-   @driver ||= driver
-   goto if visit && respond_to?(:goto)
+    if driver.is_a? Watir::Browser
+      @driver ||= driver
+      initialize_page if respond_to?(:initialize_page)
+      goto if visit && respond_to?(:goto)
+    else
+      raise ArgumentError, "expect Watir::Browser"
+    end
   end
 
   # @private
@@ -56,6 +72,13 @@ module Druid
     driver.goto url
   end
 
+  #
+  # get the current page url
+  #
+  def current_url
+    driver.url
+  end
+
   #
   # Returns the text of the current page
   #
@@ -77,4 +100,229 @@ module Druid
     driver.title
   end
 
+  #
+  # Refresh current page
+  #
+  def refresh
+    driver.refresh
+  end
+
+  #
+  # Go back to the previous page
+  #
+  def back
+    driver.back
+  end
+
+  #
+  # Go forward to the next page
+  #
+  def forward
+    driver.forward
+  end
+  #
+  # Wait until the block returns true or times out
+  #
+  # @example
+  #   @page.wait_until(5, 'Success not found on page') do
+  #     @page.text.include? 'Success'
+  #   end
+  #
+  # @param [Numeric] the amount of time to wait for the block to return true
+  # @param [String] the message to include with the error if we exceed the timeout duration
+  # @param block the block to execute. It should return true when successful.
+  #
+  def wait_until(timeout = 30, message = nil, &block)
+    driver.wait_until(timeout, message, &block)
+  end
+
+  #
+  # Override the normal alert popup so it does not occurr.
+  #
+  # @example
+  #   message = @page.alert do
+  #     @page.button_that_causes_alert
+  #   end
+  #
+  # @param block a block that has the call that will cause the alert to display
+  # @return [String] the message that was contained in the alert
+  #
+  def alert(&block)
+    # switch_to_frame(frame)
+    yield
+    value = nil
+    if driver.alert.exists?
+      value = driver.alert.text
+      driver.alert.ok
+    end
+    # switch_to_default_content(frame)
+    value
+  end
+
+  #
+  # Override the normal confirm popup so it does not occurr
+  #
+  # @example
+  #   message = @popup.confirm(true) do
+  #     @page.button_that_causes_confirm
+  #   end
+  #
+  # @param [boolean] what response you want to return back from the confirm popup
+  # @param block a block that has the call that will cause the confirm to display
+  # @return [String] the message that was contained in the confirm
+  #
+  def confirm(response, &block)
+    yield
+    value = nil
+    if driver.alert.exists?
+      value = driver.alert.text
+      response ? driver.alert.ok : driver.alert.close
+    end
+    value
+  end
+
+  #
+  # Override the normal prompt popup so it does not occurr
+  #
+  # @example
+  #   message = @popup.prompt("Some Value") do
+  #     @page.button_that_causes_prompt
+  #   end
+  #
+  # @param [String] the value will be setted in the prompt field
+  # @param block a block that has the call that will cause the prompt to display
+  # @return [String] the message that was contained in the prompt
+  #
+  def prompt(answer, &block)
+    yield
+    value = nil
+    if driver.alert.exists?
+      value = driver.alert.text
+      driver.alert.set answer
+      driver.alert.ok
+    end
+    value
+  end
+
+  #
+  # Attach to a running window. You can locate the window using either
+  # the window's title or url or index, If it failes to connect to a window it will
+  # pause for 1 second and try again.
+  #
+  # @example
+  #   @page.attach_to_window(:title => "other window's title")
+  #
+  # @param [Hash] either :title or :url or index of the other window. The url does not need to
+  # be the entire url - it can just be the page name like index.html
+  #
+  def attach_to_window(identifier, &block)
+    if identifier.keys.first == :url
+      win_id = {identifier.keys.first => /#{Regexp.escape(identifier.values.first)}/}
+    else
+      win_id = {identifier.keys.first => identifier.values.first}
+    end
+    begin
+      driver.window(win_id).use &block
+    rescue
+      sleep 1
+      driver.window(win_id).use &block
+    end
+  end
+
+  #
+  # Override the normal showModalDialog call is it opens a window instead of a dialog.
+  # You will need to attach to the new window in order to continue.
+  #
+  # @example
+  #   @page.modal_dialog do
+  #     @page.action_that_spawns_the_modal
+  #   end
+  #
+  # @param block a block that contains the call that will cause the modal dialog.
+  #
+  def modal_dialog(&block)
+    script =
+    %Q{
+      window.showModalDialog = function(sURL, vArguments, sFeatures) {
+        window.dialogArguments = vArguments;
+        modalWin = window.open(sURL, 'modal', sFeatures);
+        return modalWin;
+      }
+    }
+    driver.execute_script script
+    yield if block_given?
+  end
+
+  #
+  # Clear the cookies from the browser
+  #
+  def clear_cookies
+    driver.clear_cookies
+  end
+
+  #
+  # Save the current screenshot to the provided path. File is saved as a png file.
+
+  def save_screenshot(file_name)
+    driver.screenshot.save(file_name)
+  end
+
+  #
+  # Identify an element as existing within a frame or iframe. A frame parameter is
+  # passed to the block and must be passed to the other calls to Druid.
+  # You can nest calls to in_frame by passing the frame to the next level.
+  #
+  # @example
+  #  @page.in_frame(:id => 'frame_id') do |frame|
+  #    @page.text_field_element(:id=> 'fname', :frame => frame)
+  #  end
+  #
+  # @param [Hash] identifier how we find the frame. The valid keys are:
+  #    * :id
+  #    * :index
+  #    * :name
+  # @param block that contains the calls to elements that exist inside the frame.
+  #
+  def in_frame(identifier, frame=nil, &block)
+    frame = [] if frame.nil?
+    frame << {frame: identifier}
+    block.call(frame)
+  end
+
+  #
+  # Identify an element as existing within a frame or iframe. A frame parameter is
+  # passed to the block and must be passed to the other calls to Druid.
+  # You can nest calls to in_frame by passing the frame to the next level.
+  #
+  # @example
+  #  @page.in_iframe(:id => 'frame_id') do |frame|
+  #    @page.text_field_element(:id=> 'fname', :frame => frame)
+  #  end
+  #
+  # @param [Hash] identifier how we find the frame. The valid keys are:
+  #    * :id
+  #    * :index
+  #    * :name
+  # @param block that contains the calls to elements that exist inside the frame.
+  #
+  def in_iframe(identifier, frame=nil, &block)
+    frame = [] if frame.nil?
+    frame << {iframe: identifier}
+    block.call(frame)
+  end
+
+  # def switch_to_frame(frame_identifiers)
+  #   unless frame_identifiers.nil?
+  #     frame_identifiers.each do |frame|
+  #       frame_id = frame.values.first
+  #       value = frame_id.values.first
+  #       driver.wd.switch_to.frame(value)
+  #     end
+  #   end
+  # end
+
+  def call_block(&block)
+    block.arity == 1 ? block.call(self) : self.instance_eval(&block)
+  end
+
 end

data/lib/druid/accessors.rb

@@ -17,12 +17,51 @@ module Druid
         driver.goto url
       end
     end
+
+    #
+    # Identify an element as existing within a frame or iframe.
+    #
+    # @example
+    #  in_frame(:id => 'frame_id') do |frame|
+    #    text_field(:first_name, :id=> 'fname', :frame => frame)
+    #  end
+    #
+    # @param [Hash] identifier how we find the frame. The valid keys are:
+    #    * :id
+    #    * :index
+    #    * :name
+    # @param block that contains the calls to elements that exist inside the frame.
+    #
+    def in_frame(identifier, frame=nil, &block)
+      frame = [] if frame.nil?
+      frame << {frame: identifier}
+      block.call(frame)
+    end
+    #
+    # Identify an element as existing within a frame or iframe.
+    #
+    # @example
+    #  in_iframe(:id => 'frame_id') do |frame|
+    #    text_field(:first_name, :id=> 'fname', :frame => frame)
+    #  end
+    #
+    # @param [Hash] identifier how we find the frame. The valid keys are:
+    #    * :id
+    #    * :index
+    #    * :name
+    # @param block that contains the calls to elements that exist inside the frame.
+    #
+    def in_iframe(identifier, frame=nil, &block)
+      frame = [] if frame.nil?
+      frame << {iframe: identifier}
+      block.call(frame)
+    end
     #
-    # add two methods - one to select a link and another
-    # to return a link element
+    # add three methods - one to select a link and another
+    # to return a link element, and another one to select a link and not wait for the corresponding action to complete
     #
     # Example: link(:add_to_cart, :text => "Add to Cart")
-    # will generate the 'add_to_cart' and 'add_to_cart_link'
+    # will generate the 'add_to_cart' and 'add_to_cart_element', 'add_to_cart_no_wait'
     # methods.
     #
     # @param the name used for the generated methods
@@ -36,24 +75,26 @@ module Druid
     #   :xpath
     #   :link
     #   :link_text
-    def link(name, identifier)
-      identifier = Elements::Link.identifier_for identifier
+    def link(name, identifier=nil, &block)
       define_method(name) do
-        puts "#{name} method generated"
-        driver.link(identifier).click
+        return click_link_for identifier.clone unless block_given?
+        self.send("#{name}_element").click
       end
-      define_method("#{name}_link") do
-        puts "#{name}_link method generated"
-        driver.link(identifier)
+      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
+      alias_method "#{name}_link".to_sym, "#{name}_element".to_sym
     end
+
     #
     # adds three methods to the page object - one to set text in a text field,
     # another to retrieve text from a text field and another to return the text
     # field element.
     #
     # Example:  text_field(:first_name, {:id => "first_name"})
-    # will generate the 'first_name', 'first_name=' and 'first_name_text_field methods.
+    # will generate the 'first_name', 'first_name=' and 'first_name_element methods.
     #
     # @param  the name used for the generated methods
     # @param identifier how we find a text_field.  The valid values are:
@@ -64,20 +105,23 @@ module Druid
     #   :name
     #   :tag_name
     #   :xpath
-    def text_field(name, identifier)
-      identifier = Elements::TextField.identifier_for identifier
+    #   :text
+    #   :title
+    def text_field(name, identifier=nil, &block)
       define_method(name) do
-        puts "#{name} method generated"
-        driver.text_field(identifier).value
+        return text_field_value_for identifier.clone unless block_given?
+        self.send("#{name}_element").value
       end
       define_method("#{name}=") do |value|
-        puts "#{name}= method generated"
-        driver.text_field(identifier).set value
+        return text_field_value_set(identifier.clone, value) unless block_given?
+        self.send("#{name}_element").value = value
       end
-      define_method("#{name}_text_field") do
-        puts "#{name}_element method generated"
-        driver.text_field(identifier)
+      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
+      alias_method "#{name}_text_field".to_sym, "#{name}_element".to_sym
     end
     #
     # adds four methods - one to check, another to uncheck, another
@@ -86,7 +130,7 @@ module Druid
     #
     # Example: checkbox(:active, {:name => "is_active"})
     # will generate the 'check_active', 'uncheck_active',
-    # 'active_checked?' and 'active_checkbox' methods.
+    # 'active_checked?' and 'active_element' methods.
     #
     # @param the name used for the generated methods
     # @param identifier how we find a checkbox.  The valid values are:
@@ -95,25 +139,27 @@ module Druid
     #   :index
     #   :name
     #   :xpath
+    #   :value
     #
-    def checkbox(name, identifier)
-      identifier = Elements::CheckBox.identifier_for identifier
+    def checkbox(name, identifier=nil, &block)
       define_method("check_#{name}") do
-        puts "check_#{name} method generated"
-        driver.checkbox(identifier).set
+        return check_checkbox identifier.clone unless block_given?
+        self.send("#{name}_element").check
       end
       define_method("uncheck_#{name}") do
-        puts "uncheck_#{name} method generated"
-        driver.checkbox(identifier).clear
+        return uncheck_checkbox identifier.clone unless block_given?
+        self.send("#{name}_element").uncheck
       end
       define_method("#{name}_checked?") do
-        puts "#{name}_checked? method generated"
-        driver.checkbox(identifier).set?
+        return checkbox_checked? identifier.clone unless block_given?
+        self.send("#{name}_element").checked?
       end
-      define_method("#{name}_checkbox") do
-        puts "#{name}_checkbox method generated"
-        driver.checkbox(identifier)
+      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
+      alias_method "#{name}_checkbox".to_sym, "#{name}_element".to_sym
     end
     #
     # adds three methods - one to select an item in a drop-down,
@@ -121,7 +167,7 @@ module Druid
     # to retrieve the select list element.
     #
     # Example:  select_list(:state, {:id => "state"})
-    # will generate the 'state', 'state=' and 'state_select_list' methods
+    # will generate the 'state', 'state=' and 'state_element' methods
     #
     # @param the name used for the generated methods
     # @param identifier how we find a select_list.  The valid values are:
@@ -131,21 +177,21 @@ module Druid
     #   :name
     #   :xpath
     #
-    def select_list(name, identifier)
-      identifier = Elements::SelectList.identifier_for identifier
+    def select_list(name, identifier=nil, &block)
       define_method(name) do
-        puts "#{name} method generated"
-        driver.select_list(identifier).value
+        return select_list_value_for identifier.clone unless block_given?
+        self.send("#{name}_element").value
       end
       define_method("#{name}=") do |value|
-        puts "#{name}= method generated"
-        driver.select_list(identifier).select value
+        return select_list_value_set(identifier.clone, value) unless block_given?
+        self.send("#{name}_element").select(value)
       end
-      define_method("#{name}_select_list") do
-        puts "#{name}_select_list method generated"
-        element = driver.select_list(identifier)
-        Druid::Elements::SelectList.new(element)
+      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
+      alias_method "#{name}_select_list".to_sym, "#{name}_element".to_sym
     end
     #
     # adds three methods - one to select
@@ -154,7 +200,7 @@ module Druid
     #
     # Example:  radio_button(:north, {:id => "north"})
     # will generate 'select_north'
-    # 'north_selected?' and 'north_radio_button' methods
+    # 'north_selected?' and 'north_element' methods
     #
     # @param the name used for the generated methods
     # @param identifier how we find a radio_button.  The valid values are:
@@ -163,28 +209,34 @@ module Druid
     #   :index
     #   :name
     #   :xpath
+    #   :value
     #
-    def radio_button(name, identifier)
-      identifier = Elements::RadioButton.identifier_for identifier
+    def radio_button(name, identifier=nil, &block)
       define_method("select_#{name}") do
-        puts "select_#{name} method generated"
-        driver.radio(identifier).set
+        return select_radio identifier.clone unless block_given?
+        self.send("#{name}_element").select
+      end
+      define_method("clear_#{name}") do
+        return clear_radio identifier.clone unless block_given?
+        self.send("#{name}_element").clear
       end
       define_method("#{name}_selected?") do
-        puts "#{name}_selected method generated"
-        driver.radio(identifier).set?
+        return radio_selected? identifier.clone unless block_given?
+        self.send("#{name}_element").selected?
       end
-      define_method("#{name}_radio_button") do
-        puts "#{name}_radio_button method generated"
-        driver.radio(identifier)
+      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
+      alias_method "#{name}_radio_button".to_sym, "#{name}_element".to_sym
     end
     #
     # adds two methods - one to click a button and another to
     # return the button element.
     #
     # Example: button(:purchase, :id => 'purchase')
-    # will generate a 'purchase' and 'purchase_button' methods.
+    # will generate a 'purchase' and 'purchase_element' methods.
     #
     # @param the name used for the generated methods
     # @param identifier how we find a button.  The valid values are:
@@ -194,24 +246,27 @@ module Druid
     #   :name
     #   :text
     #   :xpath
+    #   :src
+    #   :alt
     #
-    def button(name, identifier)
-      identifier = Elements::Button.identifier_for identifier
+    def button(name, identifier=nil, &block)
       define_method(name) do
-        puts "#{name} method generated"
-        driver.button(identifier).click
+        return click_button_for identifier.clone unless block_given?
+        self.send("#{name}_element").click
       end
-      define_method("#{name}_button") do
-        puts "#{name}_button method generated"
-        driver.button(identifier)
+      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
+      alias_method "#{name}_button".to_sym, "#{name}_element".to_sym
     end
     #
     # adds two methods - one to retrieve the text from a div
     # and another to return the div element
     #
     # Example:  div(:message, {:id => 'message'})
-    # will generate a 'message' and 'message_div' methods
+    # will generate a 'message' and 'message_element' methods
     #
     # @param the name used for the generated methods
     # @param identifier how we find a div.  The valid values are:
@@ -220,24 +275,26 @@ module Druid
     #   :index
     #   :xpath
     #   :name
+    #   :text
+    #   :value
     #
-    def div(name, identifier)
-      identifier = add_tagname_if_needed identifier, "div"
-      identifier = Elements::Div.identifier_for identifier
+    def div(name, identifier=nil, &block)
       define_method(name) do
-        puts "#{name} method generated"
-        driver.div(identifier).text
+        return div_text_for identifier.clone unless block_given?
+        self.send("#{name}_element").text
       end
-      define_method("#{name}_div") do
-        puts "#{name}_div method generated"
-        driver.div(identifier)
+      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
+      alias_method "#{name}_div".to_sym, "#{name}_element".to_sym
     end
     #
     # adds a method to retrieve the table element
     #
     # Example: table(:cart, :id => 'shopping_cart')
-    # will generate a 'cart_table' method.
+    # will generate a 'cart_element' method.
     #
     # @param the name used for the generated methods
     # @param identifier how we find a table.  The valid values are:
@@ -247,21 +304,20 @@ module Druid
     #   :xpath
     #   :name
     #
-    def table(name, identifier)
-      identifier = add_tagname_if_needed identifier, "table"
-      identifier = Elements::Table.identifier_for identifier
-      define_method("#{name}_table") do
-        puts "#{name}_table method generated"
-        element = driver.table(identifier)
-        Druid::Elements::Table.new(element)
+    def table(name, identifier=nil, &block)
+      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
+      alias_method "#{name}_table".to_sym, "#{name}_element".to_sym
     end
     #
     # adds two methods  one to retrieve the text from a table cell
     # and another to return the table cell element
     #
     # Example: cell(:total, :id => 'total_cell')
-    # will generate a 'total' and 'total_cell' methods
+    # will generate a 'total' and 'total_element' methods
     #
     # @param the name used for the generated methods
     # @param identifier how we find a cell.  The valid values are:
@@ -270,25 +326,26 @@ module Druid
     #   :index
     #   :xpath
     #   :name
+    #   :text
     #
-    def cell(name, identifier)
-      identifier = add_tagname_if_needed identifier, "td"
-      identifier = Elements::TableCell.identifier_for identifier
+    def cell(name, identifier=nil, &block)
       define_method(name) do
-        puts "#{name} method generated"
-        driver.td(identifier).text
+        return cell_text_for identifier.clone unless block_given?
+        self.send("#{name}_element").text
       end
-      define_method("#{name}_cell") do
-        puts "#{name}_cell method generated"
-        driver.td(identifier)
+      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
+      alias_method "#{name}_cell".to_sym, "#{name}_element".to_sym
     end
     #
     # adds two methods - one to retrieve the text from a span
     # and another to return the span element
     #
     # Example:  span(:alert, {:id => 'alert'})
-    # will generate a 'alert' and 'alert_div' methods
+    # will generate a 'alert' and 'alert_element' methods
     #
     # @param the name used for the generated methods
     # @param identifier how we find a span.  The valid values are:
@@ -297,24 +354,25 @@ module Druid
     #   :index
     #   :xpath
     #   :name
+    #   :text
     #
-    def span(name, identifier)
-      identifier = add_tagname_if_needed identifier, "span"
-      identifier = Elements::Span.identifier_for identifier
+    def span(name, identifier=nil, &block)
       define_method(name) do
-        puts "#{name} method generated"
-        driver.span(identifier).text
+        return span_text_for identifier.clone unless block_given?
+        self.send("#{name}_element").text
       end
-      define_method("#{name}_span") do
-        puts "#{name}_span method generated"
-        driver.span(identifier)
+      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
+      alias_method "#{name}_span".to_sym, "#{name}_element".to_sym
     end
     #
     # adds a method to retrieve the image element
     #
     # Example: image(:photo, :id => 'photo_id')
-    # will generate a 'photo_image' method.
+    # will generate a 'photo_element' method.
     #
     # @param the name used for the generated methods
     # @param identifier how we find a image.  The valid values are:
@@ -323,20 +381,23 @@ module Druid
     #   :index
     #   :name
     #   :xpath
+    #   :alt
+    #   :src
     #
-    def image(name, identifier)
-      identifier = Elements::Image.identifier_for identifier
-      define_method("#{name}_image") do
-        puts "#{name}_image method generated"
-        driver.image(identifier)
+    def image(name, identifier=nil, &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
+      alias_method "#{name}_image".to_sym, "#{name}_element".to_sym
     end
     #
     # adds a method to retrieve the form element
     #
     # @example
     #   form(:login, :id => 'login')
-    #   # will generate a 'login_form' method
+    #   # will generate a 'login_element' method
     #
     # @param [String] the name used for the generated methods
     # @param [Hash] identifier how we find a form.  The valid keys are:
@@ -345,13 +406,15 @@ module Druid
     #   * :index
     #   * :xpath
     #   * :name
+    #   * :action
     #
-    def form(name, identifier)
-      identifier = Elements::Form.identifier_for identifier
-      define_method("#{name}_form") do
-        puts "#{name}_form method generated"
-        driver.form(identifier)
+    def form(name, identifier=nil, &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
+      alias_method "#{name}_form".to_sym, "#{name}_element".to_sym
     end
     #
     # adds two methods to the page object - one to get the text from a hidden field
@@ -359,7 +422,7 @@ module Druid
     #
     # @example
     #   hidden_field(:user_id, :id => "user_identity")
-    #   # will generate 'user_id' and 'user_id_hidden_field' methods
+    #   # will generate 'user_id' and 'user_id_element' methods
     #
     # @param [String] the name used for the generated methods
     # @param [Hash] identifier how we find a hidden field.  The valid keys are:
@@ -371,17 +434,19 @@ module Druid
     #   * :tag_name
     #   * :text
     #   * :xpath
+    #   * :value
     #
-    def hidden_field(name, identifier)
-      identifier = Elements::HiddenField.identifier_for identifier
-      define_method("#{name}_hidden_field") do
-        puts "#{name}_hidden_field method generated"
-        driver.hidden(identifier)
+    def hidden_field(name, identifier=nil, &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
-        puts "#{name} method generated"
-        driver.hidden(identifier).value
+        return hidden_field_value_for identifier.clone unless block_given?
+        self.send("#{name}_element").value
       end
+      alias_method "#{name}_hidden_field".to_sym, "#{name}_element".to_sym
     end
     #
     # adds two methods - one to retrieve the text from a list item
@@ -389,7 +454,7 @@ module Druid
     #
     # @example
     #   list_item(:item_one, :id => 'one')
-    #   # will generate 'item_one' and 'item_one_list_item' methods
+    #   # will generate 'item_one' and 'item_one_element' methods
     #
     # @param [String] the name used for the generated methods
     # @param [Hash] identifier how we find a list item.  The valid keys are:
@@ -399,24 +464,24 @@ module Druid
     #   * :xpath
     #   * :name
     #
-    def list_item(name, identifier)
-      identifier = add_tagname_if_needed identifier, "li"
-      identifier = Elements::ListItem.identifier_for identifier
+    def list_item(name, identifier=nil, &block)
       define_method(name) do
-        puts "#{name} method generated"
-        driver.li(identifier).text
+        return list_item_text_for identifier.clone unless block_given?
+        self.send("#{name}_element").text
       end
-      define_method("#{name}_list_item") do
-        puts "#{name}_list_item method generated"
-        driver.li(identifier)
+      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
+      alias_method "#{name}_list_item".to_sym, "#{name}_element".to_sym
     end
     #
     # adds a method to retrieve the ordered list element
     #
     # @example
     #   ordered_list(:top_five, :id => 'top')
-    #   # will generate a 'top_five_ordered_list' method
+    #   # will generate a 'top_five_element' method
     #
     # @param [String] the name used for the generated methods
     # @param [Hash] identifier how we find an ordered list.  The valid keys are:
@@ -426,14 +491,13 @@ module Druid
     #   * :xpath
     #   * :name
     #
-    def ordered_list(name, identifier)
-      identifier = add_tagname_if_needed identifier, "ol"
-      identifier = Elements::OrderedList.identifier_for identifier
-      define_method("#{name}_ordered_list") do
-        puts "#{name}_ordered_list method generated"
-        element = driver.ol(identifier)
-        Druid::Elements::OrderedList.new(element)
+    def ordered_list(name, identifier=nil, &block)
+      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
+      alias_method "#{name}_ordered_list".to_sym, "#{name}_element".to_sym
     end
     #
     # adds three methods to the page object - one to set text in a text area,
@@ -442,7 +506,7 @@ module Druid
     #
     # @example
     #   text_area(:address, :id => "address")
-    #   # will generate 'address', 'address=' and 'address_text_area methods
+    #   # will generate 'address', 'address=' and 'address_element' methods
     #
     # @param  [String] the name used for the generated methods
     # @param [Hash] identifier how we find a text area.  The valid keys are:
@@ -454,27 +518,28 @@ module Druid
     #   * :tag_name
     #   * :xpath
     #
-    def text_area(name, identifier)
-      identifier = Elements::TextArea.identifier_for identifier
+    def text_area(name, identifier=nil, &block)
       define_method("#{name}=") do |value|
-        puts "#{name}= method generated"
-        driver.textarea(identifier).send_keys value
+        return text_area_value_set(identifier.clone, value) unless block_given?
+        self.send("#{name}_element").value = value
       end
-      define_method("#{name}") do
-        puts "#{name} method generated"
-        driver.textarea(identifier).value
+      define_method(name) do
+        return text_area_value_for identifier.clone unless block_given?
+        self.send("#{name}_element").value
       end
-      define_method("#{name}_text_area") do
-        puts "#{name}_text_area method generated"
-        driver.textarea(identifier)
+      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
+      alias_method "#{name}_text_area".to_sym, "#{name}_element".to_sym
     end
     #
     # adds a method to retrieve the unordered list element
     #
     # @example
     #   unordered_list(:menu, :id => 'main_menu')
-    #   # will generate a 'menu_unordered_list' method
+    #   # will generate a 'menu_element' method
     #
     # @param [String] the name used for the generated methods
     # @param [Hash] identifier how we find an unordered list.  The valid keys are:
@@ -484,23 +549,246 @@ module Druid
     #   * :xpath
     #   * :name
     #
-    def unordered_list(name, identifier)
-      identifier = add_tagname_if_needed identifier, "ul"
-      identifier = Elements::UnOrderedList.identifier_for identifier
-      define_method("#{name}_unordered_list") do
-        puts "#{name}_unordered_list method generated"
-        element = driver.ul(identifier)
-        Druid::Elements::UnOrderedList.new(element)
+    def unordered_list(name, identifier=nil, &block)
+      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
+      alias_method "#{name}_unordered_list".to_sym, "#{name}_element".to_sym
     end
 
-    private
+    #
+    # adds a method to retrieve the text of a h1 and a h1 element
+    #
+    # @example
+    #   h1(:title, :id => 'title')
+    #   # will generate a 'title' and 'title_element' method
+    #
+    # @param [String] the name used for the generated methods
+    # @param [Hash] identifier how we find a H1.  You can use a multiple paramaters
+    #   by combining of any of the following except xpath.  The valid keys are:
+    #   * :class
+    #   * :id
+    #   * :index
+    #   * :name
+    #   * :xpath
+    # @param optional block to be invoked when element method is called
+    #
+    def h1(name, identifier=nil, &block)
+      define_method(name) do
+        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
+      alias_method "#{name}_h1".to_sym, "#{name}_element".to_sym
+    end
 
-    def add_tagname_if_needed identifier, tag
-      return identifier if identifier.length < 2 and not identifier[:name]
-      identifier[:tag_name] = tag if identifier[:name]
-      identifier
+    #
+    # adds a method to retrieve the text of a h2 and a h2 element
+    #
+    # @example
+    #   h2(:title, :id => 'title')
+    #   # will generate a 'title' and 'title_element' method
+    #
+    # @param [String] the name used for the generated methods
+    # @param [Hash] identifier how we find a H2.  You can use a multiple paramaters
+    #   by combining of any of the following except xpath.  The valid keys are:
+    #   * :class
+    #   * :id
+    #   * :index
+    #   * :name
+    #   * :xpath
+    # @param optional block to be invoked when element method is called
+    #
+    def h2(name, identifier=nil, &block)
+      define_method(name) do
+        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
+      alias_method "#{name}_h2".to_sym, "#{name}_element".to_sym
+    end
+
+    #
+    # adds a method to retrieve the text of a h3 and a h3 element
+    #
+    # @example
+    #   h3(:title, :id => 'title')
+    #   # will generate a 'title' and 'title_element' method
+    #
+    # @param [String] the name used for the generated methods
+    # @param [Hash] identifier how we find a H3.  You can use a multiple paramaters
+    #   by combining of any of the following except xpath.  The valid keys are:
+    #   * :class
+    #   * :id
+    #   * :index
+    #   * :name
+    #   * :xpath
+    # @param optional block to be invoked when element method is called
+    #
+    def h3(name, identifier=nil, &block)
+      define_method(name) do
+        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
+      alias_method "#{name}_h3".to_sym, "#{name}_element".to_sym
+    end
+
+    #
+    # adds a method to retrieve the text of a h4 and a h4 element
+    #
+    # @example
+    #   h4(:title, :id => 'title')
+    #   # will generate a 'title' and 'title_element' method
+    #
+    # @param [String] the name used for the generated methods
+    # @param [Hash] identifier how we find a H4.  You can use a multiple paramaters
+    #   by combining of any of the following except xpath.  The valid keys are:
+    #   * :class
+    #   * :id
+    #   * :index
+    #   * :name
+    #   * :xpath
+    # @param optional block to be invoked when element method is called
+    #
+    def h4(name, identifier=nil, &block)
+      define_method(name) do
+        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
+      alias_method "#{name}_h4".to_sym, "#{name}_element".to_sym
+    end
+
+    #
+    # adds a method to retrieve the text of a h5 and a h5 element
+    #
+    # @example
+    #   h5(:title, :id => 'title')
+    #   # will generate a 'title' and 'title_element' method
+    #
+    # @param [String] the name used for the generated methods
+    # @param [Hash] identifier how we find a H5.  You can use a multiple paramaters
+    #   by combining of any of the following except xpath.  The valid keys are:
+    #   * :class
+    #   * :id
+    #   * :index
+    #   * :name
+    #   * :xpath
+    # @param optional block to be invoked when element method is called
+    #
+    def h5(name, identifier=nil, &block)
+      define_method(name) do
+        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
+      alias_method "#{name}_h5".to_sym, "#{name}_element".to_sym
     end
-  end
 
+    #
+    # adds a method to retrieve the text of a h6 and a h6 element
+    #
+    # @example
+    #   h6(:title, :id => 'title')
+    #   # will generate a 'title' and 'title_element' method
+    #
+    # @param [String] the name used for the generated methods
+    # @param [Hash] identifier how we find a H6.  You can use a multiple paramaters
+    #   by combining of any of the following except xpath.  The valid keys are:
+    #   * :class
+    #   * :id
+    #   * :index
+    #   * :name
+    #   * :xpath
+    # @param optional block to be invoked when element method is called
+    #
+    def h6(name, identifier=nil, &block)
+      define_method(name) do
+        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
+      alias_method "#{name}_h6".to_sym, "#{name}_element".to_sym
+    end
+
+    #
+    # adds a method to retrieve the text of a paragraph and a paragraph element
+    #
+    # @example
+    #   paragraph(:title, :id => 'title')
+    #   # will generate a 'title' and 'title_element' method
+    #
+    # @param [String] the name used for the generated methods
+    # @param [Hash] identifier how we find a paragraph.  You can use a multiple paramaters
+    #   by combining of any of the following except xpath.  The valid keys are:
+    #   * :class
+    #   * :id
+    #   * :index
+    #   * :name
+    #   * :xpath
+    # @param optional block to be invoked when element method is called
+    #
+    def paragraph(name, identifier=nil, &block)
+      define_method(name) do
+        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
+      alias_method "#{name}_paragraph".to_sym, "#{name}_element".to_sym
+    end
+
+    #
+    # adds a method to set the file for a file field and to retrieve
+    # the file field element
+    #
+    # @example
+    #   file_field(:the_file, :id => 'file_to_upload')
+    #   # will generate a 'the_file=' and 'the_file_element' method
+    #
+    # @param [String] the name used for the generated methods
+    # @param [Hash] identifier how we find a file_field.  You can use a multiple paramaters
+    #   by combining of any of the following except xpath.  The valid keys are:
+    #   * :class
+    #   * :id
+    #   * :index
+    #   * :name
+    #   * :title
+    #   * :xpath
+    # @param optional block to be invoked when element method is called
+    #
+    def file_field(name, identifier=nil, &block)
+      define_method("#{name}=") do |value|
+        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
+    end
+  end
 end