druid-s 1.0.0

data/lib/druid/accessors.rb

@@ -0,0 +1,1082 @@
+require 'druid/elements'
+require 'erb'
+require 'druid/locator_generator'
+
+module Druid
+  #
+  # Contains the class level methods that are inserted into your page class
+  # when you include the PageObject module.  These methods will generate another
+  # set of methods that provide access to the elements on the web pages.
+  #
+  module Accessors
+
+    #
+    # Set some values that can be used withing the class. This is
+    # typically used to provided values that help build dynamic urls in
+    # the page_url method
+    #
+    # @param [Hash] the value to set the params
+    #
+    def params=(the_params)
+      @params = the_params
+    end
+
+    #
+    # Return the params that exist on this page class
+    #
+    def params
+      @params ||= {}
+    end
+
+    #
+    # Specify the url for the page.  A call to this method will generate a
+    # 'goto' method to take you to the page.
+    #
+    # @param [String] the url for the page.
+    # @param [Symbol] a method name to call to get the url
+    #
+    def page_url(url)
+      define_method("goto") do
+        driver.goto self.page_url_value
+      end
+
+      define_method("page_url_value") do
+        lookup = url.kind_of?(Symbol) ? self.send(url) : url
+        erb = ERB.new(%Q{#{lookup}})
+        merged_params = self.class.instance_variable_get("@merged_params")
+        params = merged_params ? merged_params : self.class.params
+        erb.result(binding)
+      end
+    end
+    alias_method :direct_url, :page_url
+
+    #
+    # Creates a method that waits the expected_title of a page to match the actual.
+    # @param [String] expected_title the literal expected title for the page
+    # @param [Regexp] expected_title the expected title pattern for the page
+    # @param [optional, Integer] timeout default value is nil - do not wait
+    # @return [boolean]
+    # @raise An exception if expected_title does not match actual title
+    #
+    # @example Specify 'Google' as the expected title of a page
+    #   wait_for_expected_title "Google"
+    #   page.wait_for_expected_title?
+    #
+    def wait_for_expected_title(expected_title, timeout=Druid.default_element_wait)
+      define_method("wait_for_expected_title?") do
+        error_message = lambda { "Expected title '#{expected_title}' instead of '#{title}'" }
+        has_expected_title = (expected_title === title)
+        wait_until(timeout, error_message.call) do
+          has_expected_title = (expected_title === title)
+        end unless has_expected_title
+        raise error_message.call unless has_expected_title
+        has_expected_title
+      end
+    end
+
+    #
+    # 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 [Boolean]
+    # @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
+        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
+
+    #
+    # 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] the name given to the element in the declaration
+    # @param [optional, Interger] timeout default value is 5 seconds
+    # @return [boolean]
+    #
+    # @example Specify a text box named :address expected on the page within 10 seconds
+    #   expected_element(:address, 10)
+    #   page.has_expected_element?
+    #
+    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
+    end
+
+    def expected_element_visible(element_name, timeout=Druid.default_element_wait)
+      define_method("has_expected_element_visible?") do
+        self.respond_to? "#{element_name}_element" and self.send("#{element_name}_element").when_present timeout
+        self.respond_to? "#{element_name}_element" and self.send("#{element_name}_element").when_visible timeout
+      end
+
+    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
+    #  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 frame passed from a previous call to in_frame. Used to nest calls
+    # @param block that contains the calls to elements that exist inside the frame.
+    #
+    def in_frame(identifier, frame=nil, &block)
+      frame = frame.nil? ? [] : frame.dup
+      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_iframe by passing the frame to the next level.
+    #
+    # @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 frame passed from a previous call to in_iframe. Used to nest calls
+    # @param block that contains the calls to elements that exist inside the frame.
+    #
+    def in_iframe(identifier, frame=nil, &block)
+      frame = frame.nil? ? [] : frame.dup
+      frame << {iframe: identifier}
+      block.call(frame)
+    end
+
+    #
+    # adds three methods - one to select a link, another
+    # to return a PageObject::Elements::Link object representing
+    # the link, and another that checks the link's existence.
+    #
+    # @example
+    #   link(:add_to_cart, :text => "Add to Cart")
+    #   # will generate 'add_to_cart', 'add_to_cart_element', and 'add_to_cart?' methods
+    #
+    # @param [Symbol] the name used for the generated methods
+    # @param [Hash] identifier how we find a link. You can use a multiple parameters
+    #   by combining of any of the following except xpath. The valid values are:
+    #   * :class
+    #   * :href
+    #   * :id
+    #   * :index
+    #   * :name
+    #   * :text
+    #   * :xpath
+    #   * :link
+    #   * :link_text
+    #   * :css
+    #   * :title
+    # @param optional block to be invoked when element method is called
+    #
+    def link(name, identifier={:index => 0}, &block)
+      standard_methods(name, identifier, 'link_for', &block)
+      define_method(name) do
+        return click_link_for identifier.clone unless block_given?
+        self.send("#{name}_element").click
+      end
+    end
+
+    alias_method :a, :link
+
+
+    #
+    # adds four methods to the page objec - one to set text in a text field,
+    # another to retrieve text from a text field, another to return the text
+    # field element, another to check the text field's existence.
+    #
+    # @example
+    #   text_field(:first_name, :id => "first_name")
+    #   # will generate 'first_name', 'first_name=', 'first_name_element',
+    #   # 'first_name?' methods
+    #
+    # @param [Symbol] the name used for the generated methods
+    # @param [Hash] identifier how we find a text_field. You can use a multiple parameters
+    # @param optional block to be invoked when element method is called
+    #
+    def text_field(name, identifier={:index => 0}, &block)
+      standard_methods(name, identifier, 'text_field_for', &block)
+      define_method(name) do
+        return text_field_value_for identifier.clone unless block_given?
+        self.send("#{name}_element").value
+      end
+      define_method("#{name}=") do |value|
+        return text_field_value_set(identifier.clone, value) unless block_given?
+        self.send("#{name}_element").value = value
+      end
+    end
+
+    #
+    # adds five methods - one to check, another to uncheck, another
+    # to return the state of a checkbox, another to return
+    # a PageObject::Elements::CheckBox object representing the checkbox, and
+    # a final method to check the checkbox's existence.
+    #
+    # @example
+    #   checkbox(:active, :name => "is_active")
+    #   # will generate 'check_active', 'uncheck_active', 'active_checked?',
+    #   # 'active_element', and 'active?' methods
+    #
+    # @param [Symbol] the name used for the generated methods
+    # @param [Hash] identifier how we find a checkbox. You can use a multiple parameters
+    # @param optional block to be invoked when element method is called
+    #
+    def checkbox(name, identifier={:index => 0}, &block)
+      standard_methods(name, identifier, 'checkbox_for', &block)
+      define_method("check_#{name}") do
+        return check_checkbox identifier.clone unless block_given?
+        self.send("#{name}_element").check
+      end
+      define_method("uncheck_#{name}") do
+        return uncheck_checkbox identifier.clone unless block_given?
+        self.send("#{name}_element").uncheck
+      end
+      define_method("#{name}_checked?") do
+        return checkbox_checked? identifier.clone unless block_given?
+        self.send("#{name}_element").checked?
+      end
+    end
+
+    #
+    # 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 and another to get all the available options
+    # to select from
+    #
+    # @example
+    #   select_list(:state, :id => "state")
+    #   # 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
+    # @param optional block to be invoked when element method is called
+    #
+    def select_list(name, identifier={:index => 0}, &block)
+      standard_methods(name, identifier, 'select_list_for', &block)
+      define_method(name) do
+        return select_list_value_for identifier.clone unless block_given?
+        self.send("#{name}_element").options.each {|o| return o.text if o.selected?}
+      end
+      define_method("#{name}=") do |value|
+        return select_list_value_set(identifier.clone, value) unless block_given?
+        self.send("#{name}_element").select(value)
+      end
+      define_method("#{name}_options") do
+        element = self.send("#{name}_element")
+        (element && element.options) ? element.options.collect(&:text) : []
+      end
+    end
+    alias_method :select, :select_list
+
+    #
+    # adds four methods - one to select, another to return if a radio button
+    # is selected, another method to return a PageObject::Elements::RadioButton
+    # object representing the radio button element, and another to check
+    # the radio button's existence.
+    #
+    # @example
+    #   radio_button(:north, :id => "north")
+    #   # will generate 'select_north', 'north_selected?',
+    #   # 'north_element', and 'north?' methods
+    #
+    # @param [Symbol] the name used for the generated methods
+    # @param [Hash] identifier how we find a radio_button. You can use a multiple parameters
+    # @param optional block to be invoked when element method is called
+    #
+    def radio_button(name, identifier={:index => 0}, &block)
+      standard_methods(name, identifier, 'radio_button_for', &block)
+      define_method("select_#{name}") do
+        return select_radio identifier.clone unless block_given?
+        self.send("#{name}_element").select
+      end
+      define_method("#{name}_selected?") do
+        return radio_selected? identifier.clone unless block_given?
+        self.send("#{name}_element").selected?
+      end
+    end
+    alias_method :radio, :radio_button
+
+    def radio_button_group(name, identifier)
+      define_method("select_#{name}") do |value|
+        radio_buttons_for(identifier.clone).each do |radio_elem|
+          return radio_elem.select if radio_elem.value == value
+        end
+      end
+      define_method("#{name}_values") do
+        radio_buttons_for(identifier.clone).collect { |e| e.value}
+      end
+      define_method("#{name}_selected?") do
+        radio_buttons_for(identifier.clone).each do |radio_elem|
+          return radio_elem.value if radio_elem.selected?
+        end
+        return false
+      end
+      define_method("#{name}_elements") do
+        radio_buttons_for(identifier.clone)
+      end
+      define_method("#{name}?") do
+        radio_buttons_for(identifier.clone).any?
+      end
+    end
+    #
+    # adds three methods - one to click a button, another to
+    # return the button element, and another to check the button's existence.
+    #
+    # @example
+    #   button(:purchase, :id => 'purchase')
+    #   # will generate 'purchase', 'purchase_element', and 'purchase?' methods
+    #
+    # @param [Symbol] the name used for the generated methods
+    # @param [Hash] identifier how we find a button. You can use a multiple parameters
+    # @param optional block to be invoked when element method is called
+    #
+    def button(name, identifier={:index => 0}, &block)
+      standard_methods(name, identifier, 'button_for', &block)
+      define_method(name) do
+        return click_button_for identifier.clone unless block_given?
+        self.send("#{name}_element").click
+      end
+    end
+
+    #
+    # adds three methods - one to retrieve the text from a div,
+    # another to return the div element, and another to check the div's existence.
+    #
+    # @example
+    #   div(:message, :id => 'message')
+    #   # will generate 'message', 'message_element', and 'message?' methods
+    #
+    # @param [Symbol] the name used for the generated methods
+    # @param [Hash] identifier how we find a div. You can use a multiple parameters
+    # @param optional block to be invoked when element method is called
+    #
+    def div(name, identifier={:index => 0}, &block)
+      standard_methods(name, identifier, 'div_for', &block)
+      define_method(name) do
+        return div_text_for identifier.clone unless block_given?
+        self.send("#{name}_element").text
+      end
+    end
+
+    #
+    # adds three methods - one to retrieve the text for the table, one
+    # to retrieve the table element, and another to
+    # check the table's existence.
+    #
+    # @example
+    #   table(:cart, :id => 'shopping_cart')
+    #   # will generate a 'cart', 'cart_element' and 'cart?' method
+    #
+    # @param the name used for the generated methods
+    # @param identifier how we find a table. You can use a multiple parameters
+    # @param optional block to be invoked when element method is called
+    #
+    def table(name, identifier={:index => 0}, &block)
+      standard_methods(name, identifier, 'table_for', &block)
+      define_method(name) do
+        return table_text_for identifier.clone unless block_given?
+        self.send("#{name}_element").text
+      end
+    end
+
+    #
+    # adds three methods - one to retrieve the text from a table cell,
+    # another to return the table cell element, and another to check the cell's
+    # existence.
+    #
+    # @example
+    #   cell(:total, :id => 'total_cell')
+    #   # will generate 'total', 'total_element', and 'total?' methods
+    #
+    # @param [Symbol] the name used for the generated methods
+    # @param [Hash] identifier how we find a cell. You can use a multiple parameters
+    # @param optional block to be invoked when element method is called
+    #
+    def cell(name, identifier={:index => 0}, &block)
+      standard_methods(name, identifier, 'cell_for', &block)
+      define_method(name) do
+        return cell_text_for identifier.clone unless block_given?
+        self.send("#{name}_element").text
+      end
+    end
+    alias_method :td, :cell
+
+    #
+    # adds three methods - one to retrieve the text from a table row,
+    # another to return the table row element, and another to check the row's
+    # existence.
+    #
+    # @example
+    #   row(:sums, :id => 'sum_row')
+    #   # will generate 'sums', 'sums_element', and 'sums?' methods
+    #
+    # @param [Symbol] the name used for the generated methods
+    # @param [Hash] identifier how we find a cell. You can use a multiple parameters
+    # @param optional block to be invoked when element method is called
+    #
+    def row(name, identifier={:index => 0}, &block)
+      standard_methods(name, identifier, 'row_for', &block)
+      define_method(name) do
+        return row_text_for identifier.clone unless block_given?
+        self.send("#{name}_element").text
+      end
+    end
+
+    #
+    # adds three methods - one to retrieve the text from a span,
+    # another to return the span element, and another to check the span's existence.
+    #
+    # @example
+    #   span(:alert, :id => 'alert')
+    #   # will generate 'alert', 'alert_element', and 'alert?' methods
+    #
+    # @param [Symbol] the name used for the generated methods
+    # @param [Hash] identifier how we find a span. You can use a multiple parameters
+    # @param optional block to be invoked when element method is called
+    #
+    def span(name, identifier={:index => 0}, &block)
+      standard_methods(name, identifier, 'span_for', &block)
+      define_method(name) do
+        return span_text_for identifier.clone unless block_given?
+        self.send("#{name}_element").text
+      end
+    end
+
+    #
+    # adds two methods - one to retrieve the image element, and another to
+    # check the image's existence.
+    #
+    # @example
+    #   image(:logo, :id => 'logo')
+    #   # will generate 'logo_element', 'logo_loaded?' and 'logo?' methods
+    #
+    # @param [Symbol] the name used for the generated methods
+    # @param [Hash] identifier how we find a image. You can use a multiple parameters
+    # @param optional block to be invoked when element method is called
+    #
+    def image(name, identifier={:index => 0}, &block)
+      standard_methods(name, identifier, 'image_for', &block)
+      define_method("#{name}_loaded?") do
+        return image_loaded_for identifier.clone unless block_given?
+        self.send("#{name}_element").loaded?
+      end
+    end
+    alias_method :img, :image
+
+    #
+    # adds two methods - one to retrieve the form element, and another to
+    # check the form's existence.
+    #
+    # @example
+    #   form(:login, :id => 'login')
+    #   # will generate 'login_element' and 'login?' methods
+    #
+    # @param [Symbol] the name used for the generated methods
+    # @param [Hash] identifier how we find a form. You can use a multiple parameters
+    # @param optional block to be invoked when element method is called
+    #
+    def form(name, identifier={:index => 0}, &block)
+      standard_methods(name, identifier, 'form_for', &block)
+    end
+
+    #
+    # adds three methods to the page object - one to get the text from a hidden field,
+    # another to retrieve the hidden field element, and another to check the hidden
+    # field's existence.
+    #
+    # @example
+    #   hidden_field(:user_id, :id => "user_identity")
+    #   # will generate 'user_id', 'user_id_element' and 'user_id?' methods
+    #
+    # @param [Symbol] the name used for the generated methods
+    # @param [Hash] identifier how we find a hidden field. You can use a multiple parameters
+    # @param optional block to be invoked when element method is called
+    #
+    def hidden_field(name, identifier={:index => 0}, &block)
+      standard_methods(name, identifier, 'hidden_field_for', &block)
+      define_method(name) do
+        return hidden_field_value_for identifier.clone unless block_given?
+        self.send("#{name}_element").value
+      end
+    end
+    alias_method :hidden, :hidden_field
+
+    #
+    # adds three methods - one to retrieve the text from a list item,
+    # another to return the list item element, and another to check the list item's
+    # existence.
+    #
+    # @example
+    #   list_item(:item_one, :id => 'one')
+    #   # will generate 'item_one', 'item_one_element', and 'item_one?' methods
+    #
+    # @param [Symbol] the name used for the generated methods
+    # @param [Hash] identifier how we find a list item. You can use a multiple parameters
+    # @param optional block to be invoked when element method is called
+    #
+    def list_item(name, identifier={:index => 0}, &block)
+      standard_methods(name, identifier, 'list_item_for', &block)
+      define_method(name) do
+        return list_item_text_for identifier.clone unless block_given?
+        self.send("#{name}_element").text
+      end
+    end
+    alias_method :li, :list_item
+
+    #
+    # adds three methods - one to return the text within the ordered
+    # list, one to retrieve the ordered list element, and another to
+    # test it's existence.
+    #
+    # @example
+    #   ordered_list(:top_five, :id => 'top')
+    #   # will generate 'top_five' 'top_five_element' and 'top_five?' methods
+    #
+    # @param [Symbol] the name used for the generated methods
+    # @param [Hash] identifier how we find an ordered list. You can use a multiple parameters
+    # @param optional block to be invoked when element method is called
+    #
+    def ordered_list(name, identifier={:index => 0}, &block)
+      standard_methods(name, identifier, 'ordered_list_for', &block)
+      define_method(name) do
+        return ordered_list_text_for identifier.clone unless block_given?
+        self.send("#{name}_element").text
+      end
+    end
+    alias_method :ol, :ordered_list
+
+    #
+    # adds four methods to the page object - one to set text in a text area,
+    # another to retrieve text from a text area, another to return the text
+    # area element, and another to check the text area's existence.
+    #
+    # @example
+    #   text_area(:address, :id => "address")
+    #   # will generate 'address', 'address=', 'address_element',
+    #   # 'address?' methods
+    #
+    # @param  [Symbol] the name used for the generated methods
+    # @param [Hash] identifier how we find a text area. You can use a multiple parameters
+    # @param optional block to be invoked when element method is called
+    #
+    def text_area(name, identifier={:index => 0}, &block)
+      standard_methods(name, identifier, 'text_area_for', &block)
+      define_method("#{name}=") do |value|
+        return text_area_value_set(identifier.clone, value) unless block_given?
+        self.send("#{name}_element").value = value
+      end
+      define_method(name) do
+        return text_area_value_for identifier.clone unless block_given?
+        self.send("#{name}_element").value
+      end
+    end
+    alias_method :textarea, :text_area
+
+    #
+    # adds three methods - one to return the text of unordered list, another one
+    # retrieve the unordered list element, and another to check it's existence.
+    #
+    # @example
+    #   unordered_list(:menu, :id => 'main_menu')
+    #   # will generate 'menu' 'menu_element' and 'menu?' methods
+    #
+    # @param [Symbol] the name used for the generated methods
+    # @param [Hash] identifier how we find an unordered list. You can use a multiple parameters
+    # @param optional block to be invoked when element method is called
+    def unordered_list(name, identifier={:index => 0}, &block)
+      standard_methods(name, identifier, 'unordered_list_for', &block)
+      define_method(name) do
+        return unordered_list_text_for identifier.clone unless block_given?
+        self.send("#{name}_element").text
+      end
+    end
+    alias_method :ul, :unordered_list
+
+    #
+    # adds three methods - one to retrieve the text of a h1 element, another to
+    # retrieve a h1 element, and another to check for it's existence.
+    #
+    # @example
+    #   h1(:title, :id => 'title')
+    #   # will generate 'title', 'title_element', and 'title?' methods
+    #
+    # @param [Symbol] the name used for the generated methods
+    # @param [Hash] identifier how we find a H1.  You can use a multiple paramaters
+    # @param optional block to be invoked when element method is called
+    #
+    def h1(name, identifier={:index => 0}, &block)
+      standard_methods(name, identifier, 'h1_for', &block)
+      define_method(name) do
+        return h1_text_for identifier.clone unless block_given?
+        self.send("#{name}_element").text
+      end
+    end
+
+    #
+    # adds three methods - one to retrieve the text of a h2 element, another
+    # to retrieve a h2 element, and another to check for it's existence.
+    #
+    # @example
+    #   h2(:title, :id => 'title')
+    #   # will generate 'title', 'title_element', and 'title?' methods
+    #
+    # @param [Symbol] the name used for the generated methods
+    # @param [Hash] identifier how we find a H2.  You can use a multiple paramaters
+    # @param optional block to be invoked when element method is called
+    #
+    def h2(name, identifier={:index => 0}, &block)
+      standard_methods(name, identifier, 'h2_for', &block)
+      define_method(name) do
+        return h2_text_for identifier.clone unless block_given?
+        self.send("#{name}_element").text
+      end
+    end
+
+    #
+    # adds three methods - one to retrieve the text of a h3 element,
+    # another to return a h3 element, and another to check for it's existence.
+    #
+    # @example
+    #   h3(:title, :id => 'title')
+    #   # will generate 'title', 'title_element', and 'title?' methods
+    #
+    # @param [Symbol] the name used for the generated methods
+    # @param [Hash] identifier how we find a H3.  You can use a multiple paramaters
+    # @param optional block to be invoked when element method is called
+    #
+    def h3(name, identifier={:index => 0}, &block)
+      standard_methods(name, identifier, 'h3_for', &block)
+      define_method(name) do
+        return h3_text_for identifier.clone unless block_given?
+        self.send("#{name}_element").text
+      end
+    end
+
+    #
+    # adds three methods - one to retrieve the text of a h4 element,
+    # another to return a h4 element, and another to check for it's existence.
+    #
+    # @example
+    #   h4(:title, :id => 'title')
+    #   # will generate 'title', 'title_element', and 'title?' methods
+    #
+    # @param [Symbol] the name used for the generated methods
+    # @param [Hash] identifier how we find a H4.  You can use a multiple paramaters
+    # @param optional block to be invoked when element method is called
+    #
+    def h4(name, identifier={:index => 0}, &block)
+      standard_methods(name, identifier, 'h4_for', &block)
+      define_method(name) do
+        return h4_text_for identifier.clone unless block_given?
+        self.send("#{name}_element").text
+      end
+    end
+
+    #
+    # adds three methods - one to retrieve the text of a h5 element,
+    # another to return a h5 element, and another to check for it's existence.
+    #
+    # @example
+    #   h5(:title, :id => 'title')
+    #   # will generate 'title', 'title_element', and 'title?' methods
+    #
+    # @param [Symbol] the name used for the generated methods
+    # @param [Hash] identifier how we find a H5.  You can use a multiple paramaters
+    # @param optional block to be invoked when element method is called
+    #
+    def h5(name, identifier={:index => 0}, &block)
+      standard_methods(name, identifier, 'h5_for', &block)
+      define_method(name) do
+        return h5_text_for identifier.clone unless block_given?
+        self.send("#{name}_element").text
+      end
+    end
+
+    #
+    # adds three methods - one to retrieve the text of a h6 element,
+    # another to return a h6 element, and another to check for it's existence.
+    #
+    # @example
+    #   h6(:title, :id => 'title')
+    #   # will generate 'title', 'title_element', and 'title?' methods
+    #
+    # @param [Symbol] the name used for the generated methods
+    # @param [Hash] identifier how we find a H6.  You can use a multiple paramaters
+    # @param optional block to be invoked when element method is called
+    #
+    def h6(name, identifier={:index => 0}, &block)
+      standard_methods(name, identifier, 'h6_for', &block)
+      define_method(name) do
+        return h6_text_for identifier.clone unless block_given?
+        self.send("#{name}_element").text
+      end
+    end
+
+    #
+    # adds three methods - one to retrieve the text of a paragraph, another
+    # to retrieve a paragraph element, and another to check the paragraph's existence.
+    #
+    # @example
+    #   paragraph(:title, :id => 'title')
+    #   # will generate 'title', 'title_element', and 'title?' methods
+    #
+    # @param [Symbol] the name used for the generated methods
+    # @param [Hash] identifier how we find a paragraph.  You can use a multiple paramaters
+    # @param optional block to be invoked when element method is called
+    #
+    def paragraph(name, identifier={:index => 0}, &block)
+      standard_methods(name, identifier, 'paragraph_for', &block)
+      define_method(name) do
+        return paragraph_text_for identifier.clone unless block_given?
+        self.send("#{name}_element").text
+      end
+    end
+    alias_method :p, :paragraph
+
+    #
+    # adds three methods - one to set the file for a file field, another to retrieve
+    # the file field element, and another to check it's existence.
+    #
+    # @example
+    #   file_field(:the_file, :id => 'file_to_upload')
+    #   # will generate 'the_file=', 'the_file_element', and 'the_file?' methods
+    #
+    # @param [Symbol] the name used for the generated methods
+    # @param [Hash] identifier how we find a file_field.  You can use a multiple paramaters
+    # @param optional block to be invoked when element method is called
+    #
+    def file_field(name, identifier={:index => 0}, &block)
+      standard_methods(name, identifier, 'file_field_for', &block)
+      define_method("#{name}=") do |value|
+        return file_field_value_set(identifier.clone, value) unless block_given?
+        self.send("#{name}_element").value = value
+      end
+    end
+
+    #
+    # adds three methods - one to retrieve the text from a label,
+    # another to return the label element, and another to check the label's existence.
+    #
+    # @example
+    #   label(:message, :id => 'message')
+    #   # will generate 'message', 'message_element', and 'message?' methods
+    #
+    # @param [Symbol] the name used for the generated methods
+    # @param [Hash] identifier how we find a label. You can use a multiple parameters
+    # @param optional block to be invoked when element method is called
+    #
+    def label(name, identifier={:index => 0}, &block)
+      standard_methods(name, identifier, 'label_for', &block)
+      define_method(name) do
+        return label_text_for identifier.clone unless block_given?
+        self.send("#{name}_element").text
+      end
+    end
+
+    #
+    # adds three methods - one to click the area,
+    # another to return the area element, and another to check the area's existence.
+    #
+    # @example
+    #   area(:message, :id => 'message')
+    #   # will generate 'message', 'message_element', and 'message?' methods
+    #
+    # @param [Symbol] the name used for the generated methods
+    # @param [Hash] identifier how we find an area. You can use a multiple parameters
+    # @param optional block to be invoked when element method is called
+    #
+    def area(name, identifier={:index => 0}, &block)
+      standard_methods(name, identifier, 'area_for', &block)
+      define_method(name) do
+        return click_area_for identifier.clone unless block_given?
+        self.send("#{name}_element").click
+      end
+    end
+
+    #
+    # adds two method - one to return the canvas element and another to check
+    # the canvas's existence.
+    #
+    # @example
+    #   canvas(:my_canvas, :id => 'canvas_id')
+    #   #  will generate 'my_canvas_element' and 'my_canvas?' methods
+    #
+    # @param [Symbol] the name used for the generated methods
+    # @param [Hash] identifier how we find a canvas. You can use a multiple parameters
+    # @param optional block to be invoked when element method is called
+    #
+    def canvas(name, identifier={:index => 0}, &block)
+      standard_methods(name, identifier, 'canvas_for', &block)
+    end
+
+    #
+    # adds two methods - one to return the audio element and another to check
+    # the audio's existence
+    #
+    # @example
+    #   audio(:acdc, :id => 'audio_id')
+    #   # will generate 'acdc_element' and 'acdc?' methods
+    #
+    # @param [Symbol] the name used for the generated methods
+    # @param [Hash] identifier how we find an audio element. You can use a multiple parameters
+    # @param optional block to be invoked when element method is called
+    #
+    def audio(name, identifier={:index => 0}, &block)
+      standard_methods(name, identifier, 'audio_for', &block)
+    end
+
+    #
+    # adds two methods - one to return the video element and another to check
+    # the video's existence
+    #
+    # @example
+    #   video(:movie, :id => 'video_id')
+    #   # will generate 'movie_element' and 'movie?' methods
+    #
+    # @param [Symbol] the name used for the generated methods
+    # @param [Hash] identifier how we find a video element. You can use a multiple parameters
+    # @param optional block to be invoked when element method is called
+    #
+    def video(name, identifier={:index => 0}, &block)
+      standard_methods(name, identifier, 'video_for', &block)
+    end
+
+    #
+    # adds three methods - one to retrieve the text of a b element, another to
+    # retrieve a b element, and another to check for it's existence.
+    #
+    # @example
+    #   b(:blod, :id => 'title')
+    #   # will generate 'bold', 'bold_element', 'bold?' methods
+    #
+    # @param [Symbol] the name used for the generated methods
+    # @param [Hash] identifier how we find a b, You can use a multiple parameters
+    # @param optional block to be invoked when element method is called
+    #
+    def b(name, identifier={:index => 0}, &block)
+      standard_methods(name, identifier, 'b_for', &block)
+      define_method(name) do
+        return b_text_for identifier.clone unless block_given?
+        self.send("#{name}_element").text
+      end
+    end
+
+    #
+    # adds three methods - one to retrieve the text of a i element, another to
+    # retrieve a b element, and another to check for it's existence.
+    #
+    # @example
+    #   i(:italic, :id => 'title')
+    #   # will generate 'italic', 'italic_element', 'italic?' methods
+    #
+    # @param [Symbol] the name used for the generated methods
+    # @param [Hash] identifier how we find a i, You can use a multiple parameters
+    # @param optional block to be invoked when element method is called
+    #
+    def i(name, identifier={:index => 0}, &block)
+      standard_methods(name, identifier, 'i_for', &block)
+      define_method(name) do
+        return i_text_for identifier.clone unless block_given?
+        self.send("#{name}_element").text
+      end
+    end
+    alias_method :icon, :i
+
+    #
+    # adds two methods - one to retrieve a svg, and another to check
+    # svg's existence.
+    #
+    # @example
+    #   svg(:circle, :id => 'circle')
+    #   # will generate 'circle_element', and 'circle?' methods
+    #
+    # @param [Symbol] the name used for the generated methods
+    # @param [Hash] identifier how we find a svg. You can use a multiple parameters
+    # @param optional block to be invoked when element method is called
+    #
+    def svg(name, identifier={:index => 0}, &block)
+      standard_methods(name, identifier, 'svg_for', &block)
+    end
+
+    #
+    # adds three methods - one to retrieve the text an element, another
+    # to retrieve an element, and another to check the element's existence.
+    #
+    # @example
+    #   element(:titile, :id => 'title')
+    #   # will generate 'title'm 'title_element', and 'title?' methods
+    #
+    # @param [Symbol] the name used for the generated methods
+    # @param [Hash] identifier how we find an element. You can use a multiple parameters
+    # @param optional block to be invoked when element method is called
+    #
+    def element(name, tag=:element, identifier={:index => 0}, &block)
+      #
+      # sets tag as element if not defined
+      #
+      if tag.is_a? Hash
+        identifier = tag
+        tag = :element
+      end
+
+      define_method("#{name}") do
+        self.send("#{name}_element").text
+      end
+      define_method("#{name}_element") do
+        return call_block(&block) if block_given?
+        element_for(tag, identifier.clone)
+      end
+      define_method("#{name}?") do
+        self.send("#{name}_element").exist?
+      end
+    end
+
+    #
+    # adds a method to return a collection of generic Element objects
+    # for a specific tag
+    #
+    # @example
+    #   elements(:title, :header, :id => 'title')
+    #    # will generate 'title_elements'
+    #
+    # @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 parameters
+    # @param optional block to be invoked when element method is called
+    #
+    def elements(name, tag=:element, identifier={:index => 0}, &block)
+      #
+      # sets tag as element if not defined
+      #
+      if tag.is_a? Hash
+        identifier = tag
+        tag = :element
+      end
+
+      define_method("#{name}_elements") do
+        return call_block(&block) if block_given?
+        elements_for(tag, identifier.clone)
+      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
+
+    #
+    # adds a method to return a page object rooted at the element
+    #
+    # @example
+    #   page_section(:navigation_bar, NavigationBar, :id => 'nav-bar')
+    #   # will generate 'navigation_bar'
+    #
+    # @param [Symbol] the name used for the generated methods
+    # @param [Class] the class to instantiate for the element
+    # @param [Hash] identifier how we find an element. You can use multiple parameters
+
+    def page_section(name, section_class, identifier)
+      define_method(name) do
+        page_for(identifier, section_class)
+      end
+    end
+
+    #
+    # adds a method to return a collection of page objects rooted at elements
+    #
+    # @example
+    #   page_sections(:articles, Article, :class => 'article')
+    #   # will generate 'articles'
+    #
+    # @param [Symbol] the name used for the generated method
+    # @param [Class] the class to instantiate for each element
+    # @param [Hash] identifier how we find an element. You can use a multiple parameters
+
+    def page_sections(name, section_class, identifier)
+      define_method(name) do
+        pages_for(identifier, section_class)
+      end
+    end
+
+    #
+    # methods to generate accessors for types that follow the same
+    # pattern as element
+    #
+    # @example
+    #   address(:my_article, :id => "article_id")
+    #   will generate 'my_article', 'my_article_element' and 'my_article?'
+    #
+    # @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
+    # @param optional block to be invoked when element method is called
+    #
+    LocatorGenerator::BASIC_ELEMENTS.each do |tag|
+      define_method(tag) do |name, *identifier, &block|
+        identifier = identifier[0] ? identifier[0] : {:index => 0}
+        element(name, tag, identifier, &block)
+      end
+
+      define_method("#{tag}s") do |name, *identifier, &block|
+        identifier = identifier[0] ? identifier[0] : {:index => 0}
+        elements(name, tag, identifier, &block)
+      end unless tag == :param
+    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
+    #
+    idx = LocatorGenerator::ADVANCED_ELEMENTS.find_index { |type| type == :checkbox}
+    elements = LocatorGenerator::ADVANCED_ELEMENTS.clone
+    elements[idx] = :checkboxe
+    elements.each do |method_name|
+      define_method("#{method_name}s") do |name, *identifier, &block|
+        define_method("#{name}_elements") do
+          return call_block(&block) unless block.nil?
+          platform_method = (method_name == :checkboxe) ? 'checkboxs_for' : "#{method_name.to_s}s_for"
+          self.send platform_method, (identifier.first ? identifier.first.clone : {})
+        end
+      end
+    end
+
+  end
+end