watir-page-helper 1.0.3

data/features/simple_elements/h6.feature

@@ -0,0 +1,27 @@
+Feature: h6
+  As a web developer
+  I want to locate h6 elements
+  So that I can write tests that make assertions about their content
+
+  Background:
+    When I define a page class as:
+    """
+    class PageWithH6 < BasePageClass
+      include WatirPageHelper
+      h6 :element, :id => 'h6_identifier'
+    end
+    """
+
+  Scenario: h6 element is located
+    Then I should be able to locate the element with the following code:
+    """
+    page = PageWithH6.new true
+    page.element_h6.exists?.should be_true
+    """
+
+  Scenario: h6 text is extracted
+    Then I should be able to execute the following assertion:
+    """
+    page = PageWithH6.new true
+    page.element.should == 'h6 expected content'
+    """

data/features/simple_elements/p.feature

@@ -0,0 +1,27 @@
+Feature: p
+  As a web developer
+  I want to locate p elements
+  So that I can write tests that make assertions about their content
+
+  Background:
+    When I define a page class as:
+    """
+    class PageWithP < BasePageClass
+      include WatirPageHelper
+      p :element, :id => 'p_identifier'
+    end
+    """
+
+  Scenario: p element is located
+    Then I should be able to locate the element with the following code:
+    """
+    page = PageWithP.new true
+    page.element_p.exists?.should be_true
+    """
+
+  Scenario: p text is extracted
+    Then I should be able to execute the following assertion:
+    """
+    page = PageWithP.new true
+    page.element.should == 'p expected content'
+    """

data/features/simple_elements/span.feature

@@ -0,0 +1,27 @@
+Feature: span
+  As a web developer
+  I want to locate span elements
+  So that I can write tests that make assertions about their content
+
+  Background:
+    When I define a page class as:
+    """
+    class PageWithSPAN < BasePageClass
+      include WatirPageHelper
+      span :element, :id => 'span_identifier'
+    end
+    """
+
+  Scenario: span element is located
+    Then I should be able to locate the element with the following code:
+    """
+    page = PageWithSPAN.new true
+    page.element_span.exists?.should be_true
+    """
+
+  Scenario: span text is extracted
+    Then I should be able to execute the following assertion:
+    """
+    page = PageWithSPAN.new true
+    page.element.should == 'span expected content'
+    """

data/features/step_definitions/steps.rb

@@ -0,0 +1,11 @@
+When /^I define a page class as:$/ do |string|
+  eval string
+end
+
+Then /^I should be able to locate the element with the following code:$/ do |string|
+  eval string
+end
+
+Then /^I should be able to execute the following assertion:$/ do |string|
+  eval string
+end

data/features/support/env.rb

@@ -0,0 +1,32 @@
+$: << File.join(Dir.pwd, 'lib')
+
+require 'watir-page-helper'
+require 'watir-webdriver'
+
+module Browser
+  BROWSER = Watir::Browser.new
+end
+
+World Browser
+
+class BasePageClass
+  include WatirPageHelper
+
+  direct_url "file://#{File.expand_path(File.dirname(__FILE__))}/test.html"
+
+  def initialize visit = false
+    @browser = Browser::BROWSER
+    goto if visit
+
+    expected_element if respond_to? :expected_element
+    has_expected_title? if respond_to? :has_expected_title?
+  end
+
+  def method_missing sym, *args, &block
+    @browser.send sym, *args, &block
+  end
+end
+
+at_exit do
+  Browser::BROWSER.close
+end

data/history.md

@@ -0,0 +1,10 @@
+# Gem History
+
+## 1.0.1 - 14 Mar 2012
+
+* Removed support for ripl as causing dependency conflicts on certain plaforms. See ripl-watir for this: http://rubygems.org/gems/ripl-watir
+
+## 1.0.0 - 28 Feb 2012
+
+* Added ability to extend WatirPageHelper::Page class and not have to write own 'on' and 'visit' methods
+* Added support for ripl: see http://bit.ly/ripl-watir

data/lib/watir-page-helper.rb

@@ -0,0 +1,231 @@
+require 'watir-page-helper/generated.rb'
+
+# A helper mixin to make accessing web elements via Watir-WebDriver easier.
+## This module assumes there is a @browser variable available.
+module WatirPageHelper
+
+  # A method that is called when this Module is included into a class
+  # @param [Class] cls The class that this module is being included in the literal expected title for the page
+  # @return [Nil]
+  def self.included(cls)
+    cls.extend ClassMethods
+  end
+
+  # A collection of class methods that generate helper methods that are mixed into a calling class.
+  module ClassMethods
+
+    # Creates a method that compares the expected_title of a page against the actual.
+    # @param [String] expected_title the literal expected title for the page
+    # @param [Regexp] expected_title the expected title pattern for the page
+    # @return [Nil]
+    # @raise An exception if expected_title does not match actual title
+    #
+    # @example Specify 'Google' as the expected title of a page
+    #   expected_title "Google"
+    #   page.has_expected_title?
+    def expected_title expected_title
+      define_method("has_expected_title?") do
+        has_expected_title = expected_title.kind_of?(Regexp) ? expected_title =~ @browser.title : expected_title == @browser.title
+        raise "Expected title '#{expected_title}' instead of '#{@browser.title}'" unless has_expected_title
+      end
+    end
+    
+    # Creates a method that provides a way to initialize a page based upon an expected element.
+    # This is useful for pages that load dynamic content.
+    # @param [Symbol] type the type of element you are expecting
+    # @param [Hash] identifier the name, value pair used to identify the object
+    # @param [optional, Integer] timeout default value is 30 seconds
+    # @return [Nil]
+    #
+    # @example Specify a text box as expected on the page within 10 seconds
+    #   expected_element(:text_field, :name => "firstname", 10)
+    #   page.expected_element
+    def expected_element type, identifier, timeout=30
+      define_method("expected_element") do
+        @browser.send("#{type.to_s}", identifier).wait_until_present timeout
+      end
+    end
+
+    # Provides a way to define a direct URL for a page, and creates a method for the page to go to that URL.
+    # @param [String] url the URL to directly access the page
+    # @return [Nil]
+    #
+    # @example Set the direct URL for the Google Home Page
+    #   direct_url "http://www.google.com"
+    #   page.goto # navigates to the Google URL
+    def direct_url url
+      define_method("goto") do
+        @browser.goto url
+      end
+    end
+
+    # Generates four select_list methods to:
+    # * get the value specified in a select_list
+    # * select a value in a select list;
+    # * see whether a value is selected; and
+    # * return the select_list element.
+    #
+    # @param [Symbol] name The name of the select_list element (used to generate the methods)
+    # @param [optional, Hash] identifier A set of key, value pairs to identify the element
+    # @param block
+    # @return [Nil]
+    #
+    # @example Specify a select list to generate methods
+    #   select_list :cars, :name => "cars"
+    #   page.cars = "Mazda" #select
+    #   page.cars.should == "Mazda" #check
+    #   page.cars_selected?("Mazda").should be_true #selected?
+    #   page.cars_select_list.exists?.should be_true #object
+    def select_list name, identifier=nil, &block
+      define_method(name) do
+        self.send("#{name}_select_list").value
+      end
+      define_method("#{name}=") do |value|
+        self.send("#{name}_select_list").select(value)
+      end
+      define_method("#{name}_selected?") do |value|
+        self.send("#{name}_select_list").selected?(value)
+      end
+      create_element_getter "#{name}_select_list", identifier, __method__, block
+    end
+
+    # Generates four checkbox methods to:
+    # * check the checkbox;
+    # * uncheck the checkbox;
+    # * see whether a the checkbox is checked; and
+    # * return the checkbox element.
+    #
+    # @param [Symbol] name The name of the checkbox element (used to generate the methods)
+    # @param [optional, Hash] identifier A set of key, value pairs to identify the element
+    # @param block
+    # @return [Nil]
+    #
+    # @example Specify a checkbox to generate methods
+    #   checkbox :agree, :name => "agree"
+    #   page.check_agree
+    #   page.agree?.should be_true
+    #   page.uncheck_agree
+    #   page.agree?.should be_false
+    #   page.agree_checkbox.exist?.should be_true
+    def checkbox name, identifier=nil, &block
+      define_method("check_#{name}") do
+        self.send("#{name}_checkbox").set
+      end
+      define_method("uncheck_#{name}") do
+        self.send("#{name}_checkbox").clear
+      end
+      define_method("#{name}?") do
+        self.send("#{name}_checkbox").set?
+      end
+      create_element_getter "#{name}_checkbox", identifier, __method__, block
+    end
+
+    # Generates three radio methods to:
+    # * select a radio;
+    # * see whether a radio is selected; and
+    # * return the radio element.
+    #
+    # @param [Symbol] name The name of the radio element (used to generate the methods)
+    # @param [optional, Hash] identifier A set of key, value pairs to identify the element
+    # @param block
+    # @return [Nil]
+    #
+    # @example Specify a radio button to generate methods
+    #   radio :medium, :value => "Medium"
+    #   page.select_medium
+    #   page.medium_set?.should be_true
+    #   page.medium_radio.exist?.should be_true
+    def radio name, identifier=nil, &block
+      define_method("select_#{name}") do
+        self.send("#{name}_radio").set
+      end
+      define_method("#{name}_set?") do
+        self.send("#{name}_radio").set?
+      end
+      create_element_getter "#{name}_radio", identifier, __method__, block
+      create_element_getter "#{name}_radio_button", identifier, __method__, block
+    end
+
+    def radio_button name, identifier=nil, &block
+      warn 'radio_button is a deprecated method in the watir-page-helper gem, and will be removed in future versions.'
+      radio name, identifier, &block
+    end
+
+    # Generates two row methods to:
+    # * return the text from a table row;
+    # * return the row element.
+    #
+    # @param [Symbol] name The name of the row element (used to generate the methods)
+    # @param [optional, Hash] identifier A set of key, value pairs to identify the element
+    # @param block
+    # @return [Nil]
+    #
+    # @example Specify a row to generate methods
+    #  row(:test_table_row_1) { | test_table |  test_table.tr }
+    #  page.test_table_row_1.should == "Test Table Col 1 Test Table Col 2"
+    #  page.test_table_row_1_row.cells.length.should == 2
+    def row name, identifier=nil, &block
+      define_method(name) do
+        self.send("#{name}_row").text
+      end
+      create_element_getter "#{name}_row", identifier, 'tr', block
+    end
+
+    # Generates two row methods to:
+    # * return the text from a table cell;
+    # * return the cell element.
+    #
+    # @param [Symbol] name The name of the cell element (used to generate the methods)
+    # @param [optional, Hash] identifier A set of key, value pairs to identify the element
+    # @param block
+    # @return [Nil]
+    #
+    # @example Specify a cell to generate methods
+    #  cell(:test_table_row_1_cell_1) { |test_table_row_1 | test_table_row_1.td }
+    #  page.test_table_row_1_cell_1.should == "Test Table Col 1"
+    #  page.test_table_row_1_cell_1_cell.exist?.should be_true
+    def cell name, identifier=nil, &block
+      define_method(name) do
+        self.send("#{name}_cell").text
+      end
+      create_element_getter "#{name}_cell", identifier, 'td', block
+    end
+    
+    
+    # Generates two file_field methods to:
+    # * return the text from a file field;
+    # * set a file field
+    #
+    # @param [Symbol] name The name of the file field element (used to generate the methods)
+    # @param [optional, Hash] identifier A set of key, value pairs to identify the element
+    # @param block
+    # @return [Nil]
+    #
+    # @example Specify a file_field to generate methods
+    # file_field :upload, :id => 'upload'
+    #  page.upload = image_path #set
+    #  page.upload.should == image_path #check
+    def file_field name, identifier=nil, &block
+      define_method(name) do
+        self.send("#{name}_file_field").value
+      end
+      define_method("#{name}=") do |value|
+        self.send("#{name}_file_field").set value
+      end
+      create_element_getter "#{name}_file_field", identifier, __method__, block
+    end
+    
+    private
+
+    def create_element_getter name, identifier, type, block
+      define_method name do
+        if block
+           block.arity == 1 ? block.call(self) : self.instance_eval(&block)
+        else
+          identifier.nil? ? @browser.send(type) : @browser.send(type, identifier)
+        end
+      end
+    end
+
+  end
+end

data/lib/watir-page-helper/commands.rb

@@ -0,0 +1,64 @@
+require 'watir-page-helper'
+require 'watir-webdriver'
+require 'forwardable'
+
+module WatirPageHelper
+  class Page
+    include WatirPageHelper
+    extend Forwardable
+    attr_reader :browser
+
+    def_delegators :@browser, :title, :url, :html, :status, :refresh, :back
+
+    def initialize browser
+      @browser = browser
+    end
+  end
+
+  class << self
+    attr_accessor :browser
+
+    def create
+      @browser = ::Watir::Browser.new ENV['WEBDRIVER'] || :firefox
+    end
+
+    def close
+      @browser.close
+    end
+  end
+
+  module Commands
+    def classify s
+      s.to_s.split('_').map(&:capitalize).join
+    end
+
+    def page_class *args
+      return args.first.new WatirPageHelper.browser if args.first.is_a? Class
+      page = WatirPageHelper::Page.new WatirPageHelper.browser
+      require "watir-page-helper/pages/#{args.join '/'}"
+      mod = WatirPageHelper
+      args.each do |name|
+        mod = mod.const_get classify name
+      end
+      page.extend mod
+      page
+    end
+
+    def on *args
+      page_class(*args).tap do |p|
+        p.expected_element if p.respond_to? :expected_element
+        p.has_expected_title? if p.respond_to? :has_expected_title?
+        yield p if block_given?
+      end
+    end
+
+    def visit *args
+      page_class(*args).tap do |p|
+        p.goto
+        p.expected_element if p.respond_to? :expected_element
+        p.has_expected_title? if p.respond_to? :has_expected_title?
+        yield p if block_given?
+      end
+    end
+  end
+end

data/lib/watir-page-helper/generated.rb

@@ -0,0 +1,388 @@
+module WatirPageHelper
+  module ClassMethods
+
+    # Generates two h1 methods to:
+    # * return the text from a h1;
+    # * return the h1 element.
+    #
+    # @param [Symbol] name The name of the h1 element (used to generate the methods)
+    # @param [optional, Hash] identifier A set of key, value pairs to identify the element
+    # @param block
+    # @return [Nil]
+    #
+    # @example Specify a h1 to generate methods
+    # h1 :my_element, :id => "my_element"
+    # page.my_element.should == "My Element Text"
+    # page.my_element_h1.exist?.should be_true
+    def h1 name, identifier=nil, &block
+      define_method(name) do
+        self.send("#{name}_h1").text
+      end
+      create_element_getter "#{name}_h1", identifier, __method__, block
+    end
+
+    # Generates two h2 methods to:
+    # * return the text from a h2;
+    # * return the h2 element.
+    #
+    # @param [Symbol] name The name of the h2 element (used to generate the methods)
+    # @param [optional, Hash] identifier A set of key, value pairs to identify the element
+    # @param block
+    # @return [Nil]
+    #
+    # @example Specify a h2 to generate methods
+    # h2 :my_element, :id => "my_element"
+    # page.my_element.should == "My Element Text"
+    # page.my_element_h2.exist?.should be_true
+    def h2 name, identifier=nil, &block
+      define_method(name) do
+        self.send("#{name}_h2").text
+      end
+      create_element_getter "#{name}_h2", identifier, __method__, block
+    end
+
+    # Generates two h3 methods to:
+    # * return the text from a h3;
+    # * return the h3 element.
+    #
+    # @param [Symbol] name The name of the h3 element (used to generate the methods)
+    # @param [optional, Hash] identifier A set of key, value pairs to identify the element
+    # @param block
+    # @return [Nil]
+    #
+    # @example Specify a h3 to generate methods
+    # h3 :my_element, :id => "my_element"
+    # page.my_element.should == "My Element Text"
+    # page.my_element_h3.exist?.should be_true
+    def h3 name, identifier=nil, &block
+      define_method(name) do
+        self.send("#{name}_h3").text
+      end
+      create_element_getter "#{name}_h3", identifier, __method__, block
+    end
+
+    # Generates two h4 methods to:
+    # * return the text from a h4;
+    # * return the h4 element.
+    #
+    # @param [Symbol] name The name of the h4 element (used to generate the methods)
+    # @param [optional, Hash] identifier A set of key, value pairs to identify the element
+    # @param block
+    # @return [Nil]
+    #
+    # @example Specify a h4 to generate methods
+    # h4 :my_element, :id => "my_element"
+    # page.my_element.should == "My Element Text"
+    # page.my_element_h4.exist?.should be_true
+    def h4 name, identifier=nil, &block
+      define_method(name) do
+        self.send("#{name}_h4").text
+      end
+      create_element_getter "#{name}_h4", identifier, __method__, block
+    end
+
+    # Generates two h5 methods to:
+    # * return the text from a h5;
+    # * return the h5 element.
+    #
+    # @param [Symbol] name The name of the h5 element (used to generate the methods)
+    # @param [optional, Hash] identifier A set of key, value pairs to identify the element
+    # @param block
+    # @return [Nil]
+    #
+    # @example Specify a h5 to generate methods
+    # h5 :my_element, :id => "my_element"
+    # page.my_element.should == "My Element Text"
+    # page.my_element_h5.exist?.should be_true
+    def h5 name, identifier=nil, &block
+      define_method(name) do
+        self.send("#{name}_h5").text
+      end
+      create_element_getter "#{name}_h5", identifier, __method__, block
+    end
+
+    # Generates two h6 methods to:
+    # * return the text from a h6;
+    # * return the h6 element.
+    #
+    # @param [Symbol] name The name of the h6 element (used to generate the methods)
+    # @param [optional, Hash] identifier A set of key, value pairs to identify the element
+    # @param block
+    # @return [Nil]
+    #
+    # @example Specify a h6 to generate methods
+    # h6 :my_element, :id => "my_element"
+    # page.my_element.should == "My Element Text"
+    # page.my_element_h6.exist?.should be_true
+    def h6 name, identifier=nil, &block
+      define_method(name) do
+        self.send("#{name}_h6").text
+      end
+      create_element_getter "#{name}_h6", identifier, __method__, block
+    end
+
+    # Generates two div methods to:
+    # * return the text from a div;
+    # * return the div element.
+    #
+    # @param [Symbol] name The name of the div element (used to generate the methods)
+    # @param [optional, Hash] identifier A set of key, value pairs to identify the element
+    # @param block
+    # @return [Nil]
+    #
+    # @example Specify a div to generate methods
+    # div :my_element, :id => "my_element"
+    # page.my_element.should == "My Element Text"
+    # page.my_element_div.exist?.should be_true
+    def div name, identifier=nil, &block
+      define_method(name) do
+        self.send("#{name}_div").text
+      end
+      create_element_getter "#{name}_div", identifier, __method__, block
+    end
+
+    # Generates two span methods to:
+    # * return the text from a span;
+    # * return the span element.
+    #
+    # @param [Symbol] name The name of the span element (used to generate the methods)
+    # @param [optional, Hash] identifier A set of key, value pairs to identify the element
+    # @param block
+    # @return [Nil]
+    #
+    # @example Specify a span to generate methods
+    # span :my_element, :id => "my_element"
+    # page.my_element.should == "My Element Text"
+    # page.my_element_span.exist?.should be_true
+    def span name, identifier=nil, &block
+      define_method(name) do
+        self.send("#{name}_span").text
+      end
+      create_element_getter "#{name}_span", identifier, __method__, block
+    end
+
+    # Generates two p methods to:
+    # * return the text from a p;
+    # * return the p element.
+    #
+    # @param [Symbol] name The name of the p element (used to generate the methods)
+    # @param [optional, Hash] identifier A set of key, value pairs to identify the element
+    # @param block
+    # @return [Nil]
+    #
+    # @example Specify a p to generate methods
+    # p :my_element, :id => "my_element"
+    # page.my_element.should == "My Element Text"
+    # page.my_element_p.exist?.should be_true
+    def p name, identifier=nil, &block
+      define_method(name) do
+        self.send("#{name}_p").text
+      end
+      create_element_getter "#{name}_p", identifier, __method__, block
+    end
+
+    # Generates two dl methods to:
+    # * return the text from a dl;
+    # * return the dl element.
+    #
+    # @param [Symbol] name The name of the dl element (used to generate the methods)
+    # @param [optional, Hash] identifier A set of key, value pairs to identify the element
+    # @param block
+    # @return [Nil]
+    #
+    # @example Specify a dl to generate methods
+    # dl :my_element, :id => "my_element"
+    # page.my_element.should == "My Element Text"
+    # page.my_element_dl.exist?.should be_true
+    def dl name, identifier=nil, &block
+      define_method(name) do
+        self.send("#{name}_dl").text
+      end
+      create_element_getter "#{name}_dl", identifier, __method__, block
+    end
+
+    # Generates two dd methods to:
+    # * return the text from a dd;
+    # * return the dd element.
+    #
+    # @param [Symbol] name The name of the dd element (used to generate the methods)
+    # @param [optional, Hash] identifier A set of key, value pairs to identify the element
+    # @param block
+    # @return [Nil]
+    #
+    # @example Specify a dd to generate methods
+    # dd :my_element, :id => "my_element"
+    # page.my_element.should == "My Element Text"
+    # page.my_element_dd.exist?.should be_true
+    def dd name, identifier=nil, &block
+      define_method(name) do
+        self.send("#{name}_dd").text
+      end
+      create_element_getter "#{name}_dd", identifier, __method__, block
+    end
+
+    # Generates two dt methods to:
+    # * return the text from a dt;
+    # * return the dt element.
+    #
+    # @param [Symbol] name The name of the dt element (used to generate the methods)
+    # @param [optional, Hash] identifier A set of key, value pairs to identify the element
+    # @param block
+    # @return [Nil]
+    #
+    # @example Specify a dt to generate methods
+    # dt :my_element, :id => "my_element"
+    # page.my_element.should == "My Element Text"
+    # page.my_element_dt.exist?.should be_true
+    def dt name, identifier=nil, &block
+      define_method(name) do
+        self.send("#{name}_dt").text
+      end
+      create_element_getter "#{name}_dt", identifier, __method__, block
+    end
+
+    # Generates two form methods to:
+    # * return the text from a form;
+    # * return the form element.
+    #
+    # @param [Symbol] name The name of the form element (used to generate the methods)
+    # @param [optional, Hash] identifier A set of key, value pairs to identify the element
+    # @param block
+    # @return [Nil]
+    #
+    # @example Specify a form to generate methods
+    # form :my_element, :id => "my_element"
+    # page.my_element.should == "My Element Text"
+    # page.my_element_form.exist?.should be_true
+    def form name, identifier=nil, &block
+      define_method(name) do
+        self.send("#{name}_form").text
+      end
+      create_element_getter "#{name}_form", identifier, __method__, block
+    end
+
+    # Generates two li methods to:
+    # * return the text from a li;
+    # * return the li element.
+    #
+    # @param [Symbol] name The name of the li element (used to generate the methods)
+    # @param [optional, Hash] identifier A set of key, value pairs to identify the element
+    # @param block
+    # @return [Nil]
+    #
+    # @example Specify a li to generate methods
+    # li :my_element, :id => "my_element"
+    # page.my_element.should == "My Element Text"
+    # page.my_element_li.exist?.should be_true
+    def li name, identifier=nil, &block
+      define_method(name) do
+        self.send("#{name}_li").text
+      end
+      create_element_getter "#{name}_li", identifier, __method__, block
+    end
+
+    # Generates two link methods to:
+    # * click a link;
+    # * return the link element.
+    #
+    # @param [Symbol] name The name of the link element (used to generate the methods)
+    # @param [optional, Hash] identifier A set of key, value pairs to identify the element
+    # @param block
+    # @return [Nil]
+    #
+    # @example Specify a link to generate methods
+    # link :info, :text => "Information"
+    # page.info
+    # page.info_link.exist?.should be_true
+    def link name, identifier=nil, &block
+      define_method(name) do
+        self.send("#{name}_link").click
+      end
+      create_element_getter "#{name}_link", identifier, __method__, block
+    end
+
+    # Generates two button methods to:
+    # * click a button;
+    # * return the button element.
+    #
+    # @param [Symbol] name The name of the button element (used to generate the methods)
+    # @param [optional, Hash] identifier A set of key, value pairs to identify the element
+    # @param block
+    # @return [Nil]
+    #
+    # @example Specify a button to generate methods
+    # button :info, :text => "Information"
+    # page.info
+    # page.info_button.exist?.should be_true
+    def button name, identifier=nil, &block
+      define_method(name) do
+        self.send("#{name}_button").click
+      end
+      create_element_getter "#{name}_button", identifier, __method__, block
+    end
+
+    # Generates three text_field methods to:
+    # * set a text_field;
+    # * get a text_field's value; and
+    # * return the text_field element.
+    #
+    # @param [Symbol] name The name of the text_field element (used to generate the methods)
+    # @param [optional, Hash] identifier A set of key, value pairs to identify the element
+    # @param block
+    # @return [Nil]
+    #
+    # @example Specify a text_field to generate methods
+    # text_field first_name, :name => "firstname"
+    # page.first_name = "Finley" #set
+    # page.first_name.should == "Finley" #check
+    # page.first_name_text_field.exists?.should be_true #object
+    def text_field name, identifier=nil, &block
+      define_method(name) do
+        self.send("#{name}_text_field").value
+      end
+      define_method("#{name}=") do |value|
+        self.send("#{name}_text_field").set value
+      end
+      create_element_getter "#{name}_text_field", identifier, __method__, block
+    end
+
+    # Generates a table method to return a table element.
+    # @param [Symbol] name The name of the table element (used to generate the method)
+    # @param [optional, Hash] identifier A set of key, value pairs to identify the element
+    # @param block
+    # @return [Nil]
+    #
+    # @example Specify a table to generate a method
+    #   table :my_element, :id => 'my_element'
+    #   page.my_element.exists?.should be_true
+    def table name, identifier=nil, &block
+      create_element_getter "#{name}", identifier, __method__, block
+    end
+
+    # Generates a image method to return a image element.
+    # @param [Symbol] name The name of the image element (used to generate the method)
+    # @param [optional, Hash] identifier A set of key, value pairs to identify the element
+    # @param block
+    # @return [Nil]
+    #
+    # @example Specify a image to generate a method
+    #   table :my_element, :id => 'my_element'
+    #   page.my_element.exists?.should be_true
+    def image name, identifier=nil, &block
+      create_element_getter "#{name}", identifier, __method__, block
+    end
+
+    # Generates a frame method to return a frame element.
+    # @param [Symbol] name The name of the frame element (used to generate the method)
+    # @param [optional, Hash] identifier A set of key, value pairs to identify the element
+    # @param block
+    # @return [Nil]
+    #
+    # @example Specify a frame to generate a method
+    #   table :my_element, :id => 'my_element'
+    #   page.my_element.exists?.should be_true
+    def frame name, identifier=nil, &block
+      create_element_getter "#{name}", identifier, __method__, block
+    end
+  end
+end