require 'erb' module PageObject # # Contains the class level methods that are inserted into your page objects # when you include the PageObject module. These methods will generate another # set of methods that provide access to the elements on the web pages. # # @see PageObject::WatirPageObject for the watir implementation of the platform delegate # @see PageObject::SeleniumPageObject for the selenium implementation of the platform delegate # module Accessors # # Set some values that can be used withing the class. This is # typically used to provide 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 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 platform.navigate_to erb.result(binding) end end alias_method :direct_url, :page_url # # 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 has_expected_title = expected_title === title raise "Expected title '#{expected_title}' instead of '#{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, Integer] 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=5) define_method("has_expected_element?") do self.respond_to? "#{element_name}_element" and self.send("#{element_name}_element").when_present 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 PageObject. # 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 => Watir and Selenium # * :index => Watir and Selenium # * :name => Watir and Selenium # @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 = [] if frame.nil? frame << identifier block.call(frame) end # # adds four methods to the page object - 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 [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: # * :class => Watir and Selenium # * :css => Selenium only # * :id => Watir and Selenium # * :index => Watir and Selenium # * :label => Watir and Selenium # * :name => Watir and Selenium # * :text => Watir and Selenium # * :title => Watir and Selenium # * :value => Watir only # * :xpath => Watir and Selenium # @param optional block to be invoked when element method is called # def text_field(name, identifier={:index => 0}, &block) define_method(name) do return platform.text_field_value_for identifier.clone unless block_given? self.send("#{name}_element").value end define_method("#{name}=") do |value| return platform.text_field_value_set(identifier.clone, value) unless block_given? self.send("#{name}_element").value = value end define_method("#{name}_element") do return call_block(&block) if block_given? platform.text_field_for(identifier.clone) end define_method("#{name}?") do return call_block(&block).exists? if block_given? platform.text_field_for(identifier.clone).exists? end alias_method "#{name}_text_field".to_sym, "#{name}_element".to_sym 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 [String] the name used for the generated methods # @param [Hash] identifier how we find a hidden field. You can use a multiple paramaters # by combining of any of the following except xpath. The valid keys are: # * :class => Watir and Selenium # * :css => Selenium only # * :id => Watir and Selenium # * :index => Watir and Selenium # * :name => Watir and Selenium # * :text => Watir and Selenium # * :value => Watir and Selenium # * :xpath => Watir and Selenium # @param optional block to be invoked when element method is called # def hidden_field(name, identifier={:index => 0}, &block) define_method(name) do return platform.hidden_field_value_for identifier.clone unless block_given? self.send("#{name}_element").value end define_method("#{name}_element") do return call_block(&block) if block_given? platform.hidden_field_for(identifier.clone) end define_method("#{name}?") do return call_block(&block).exists? if block_given? platform.hidden_field_for(identifier.clone).exists? end alias_method "#{name}_hidden_field".to_sym, "#{name}_element".to_sym end alias_method :hidden, :hidden_field # # 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 [String] the name used for the generated methods # @param [Hash] identifier how we find a text area. You can use a multiple paramaters # by combining of any of the following except xpath. The valid keys are: # * :class => Watir and Selenium # * :css => Selenium only # * :id => Watir and Selenium # * :index => Watir and Selenium # * :name => Watir and Selenium # * :xpath => Watir and Selenium # @param optional block to be invoked when element method is called # def text_area(name, identifier={:index => 0}, &block) define_method(name) do return platform.text_area_value_for identifier.clone unless block_given? self.send("#{name}_element").value end define_method("#{name}=") do |value| return platform.text_area_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? platform.text_area_for(identifier.clone) end define_method("#{name}?") do return call_block(&block).exists? if block_given? platform.text_area_for(identifier.clone).exists? end alias_method "#{name}_text_area".to_sym, "#{name}_element".to_sym end alias_method :textarea, :text_area # # adds four 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. # # @example # select_list(:state, :id => "state") # # will generate 'state', 'state=', 'state_element', 'state?' methods # # @param [Symbol] the name used for the generated methods # @param [Hash] identifier how we find a select list. You can use a multiple paramaters # by combining of any of the following except xpath. The valid keys are: # * :class => Watir and Selenium # * :css => Selenium only # * :id => Watir and Selenium # * :index => Watir and Selenium # * :name => Watir and Selenium # * :text => Watir only # * :value => Watir only # * :xpath => Watir and Selenium # @param optional block to be invoked when element method is called # def select_list(name, identifier={:index => 0}, &block) define_method(name) do return platform.select_list_value_for identifier.clone unless block_given? self.send("#{name}_element").value end define_method("#{name}=") do |value| return platform.select_list_value_set(identifier.clone, value) unless block_given? self.send("#{name}_element").select(value) end define_method("#{name}_element") do return call_block(&block) if block_given? platform.select_list_for(identifier.clone) end define_method("#{name}?") do return call_block(&block).exists? if block_given? platform.select_list_for(identifier.clone).exists? end alias_method "#{name}_select_list".to_sym, "#{name}_element".to_sym end alias_method :select, :select_list # # 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 paramaters # by combining of any of the following except xpath. The valid keys are: # * :class => Watir and Selenium # * :css => Watir and Selenium # * :href => Watir and Selenium # * :id => Watir and Selenium # * :index => Watir and Selenium # * :link => Watir and Selenium # * :link_text => Watir and Selenium # * :name => Watir and Selenium # * :text => Watir and Selenium # * :title => Watir and Selenium # * :xpath => Watir and Selenium # @param optional block to be invoked when element method is called # def link(name, identifier={:index => 0}, &block) define_method(name) do return platform.click_link_for identifier.clone unless block_given? self.send("#{name}_element").click end define_method("#{name}_element") do return call_block(&block) if block_given? platform.link_for(identifier.clone) end define_method("#{name}?") do return call_block(&block).exists? if block_given? platform.link_for(identifier.clone).exists? end alias_method "#{name}_link".to_sym, "#{name}_element".to_sym end alias_method :a, :link # # 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 paramaters # by combining of any of the following except xpath. The valid keys are: # * :class => Watir and Selenium # * :css => Selenium only # * :id => Watir and Selenium # * :index => Watir and Selenium # * :name => Watir and Selenium # * :value => Watir and Selenium # * :xpath => Watir and Selenium # @param optional block to be invoked when element method is called # def checkbox(name, identifier={:index => 0}, &block) define_method("check_#{name}") do return platform.check_checkbox(identifier.clone) unless block_given? self.send("#{name}_element").check end define_method("uncheck_#{name}") do return platform.uncheck_checkbox(identifier.clone) unless block_given? self.send("#{name}_element").uncheck end define_method("#{name}_checked?") do return platform.checkbox_checked?(identifier.clone) unless block_given? self.send("#{name}_element").checked? end define_method("#{name}_element") do return call_block(&block) if block_given? platform.checkbox_for(identifier.clone) end define_method("#{name}?") do return call_block(&block).exists? if block_given? platform.checkbox_for(identifier.clone).exists? end alias_method "#{name}_checkbox".to_sym, "#{name}_element".to_sym end # # adds five methods - one to select, another to clear, # 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', 'clear_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 paramaters # by combining of any of the following except xpath. The valid keys are: # * :class => Watir and Selenium # * :css => Selenium only # * :id => Watir and Selenium # * :index => Watir and Selenium # * :name => Watir and Selenium # * :value => Watir and Selenium # * :xpath => Watir and Selenium # @param optional block to be invoked when element method is called # def radio_button(name, identifier={:index => 0}, &block) define_method("select_#{name}") do return platform.select_radio(identifier.clone) unless block_given? self.send("#{name}_element").select end define_method("clear_#{name}") do return platform.clear_radio(identifier.clone) unless block_given? self.send("#{name}_element").clear end define_method("#{name}_selected?") do return platform.radio_selected?(identifier.clone) unless block_given? self.send("#{name}_element").selected? end define_method("#{name}_element") do return call_block(&block) if block_given? platform.radio_button_for(identifier.clone) end define_method("#{name}?") do return call_block(&block).exists? if block_given? platform.radio_button_for(identifier.clone).exists? end alias_method "#{name}_radio_button".to_sym, "#{name}_element".to_sym end alias_method :radio, :radio_button # # 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 paramaters # by combining of any of the following except xpath. The valid keys are: # * :class => Watir and Selenium # * :css => Watir and Selenium # * :id => Watir and Selenium # * :index => Watir and Selenium # * :name => Watir and Selenium # * :text => Watir and Selenium # * :value => Watir and Selenium # * :xpath => Watir and Selenium # * :src => Watir and Selenium (input type=image only) # * :alt => Watir and Selenium (input type=image only) # @param optional block to be invoked when element method is called # def button(name, identifier={:index => 0}, &block) define_method(name) do return platform.click_button_for identifier.clone unless block_given? self.send("#{name}_element").click end define_method("#{name}_element") do return call_block(&block) if block_given? platform.button_for(identifier.clone) end define_method("#{name}?") do return call_block(&block).exists? if block_given? platform.button_for(identifier.clone).exists? end alias_method "#{name}_button".to_sym, "#{name}_element".to_sym 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 paramaters # by combining of any of the following except xpath. The valid keys are: # * :class => Watir and Selenium # * :css => Selenium only # * :id => Watir and Selenium # * :index => Watir and Selenium # * :name => Watir and Selenium # * :text => Watir and Selenium # * :title => Watir and Selenium # * :xpath => Watir and Selenium # @param optional block to be invoked when element method is called # def div(name, identifier={:index => 0}, &block) define_method(name) do return platform.div_text_for identifier.clone unless block_given? self.send("#{name}_element").text end define_method("#{name}_element") do return call_block(&block) if block_given? platform.div_for(identifier.clone) end define_method("#{name}?") do return call_block(&block).exists? if block_given? platform.div_for(identifier.clone).exists? end alias_method "#{name}_div".to_sym, "#{name}_element".to_sym 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 paramaters # by combining of any of the following except xpath. The valid keys are: # * :class => Watir and Selenium # * :css => Selenium only # * :id => Watir and Selenium # * :index => Watir and Selenium # * :name => Watir and Selenium # * :text => Watir and Selenium # * :title => Watir and Selenium # * :xpath => Watir and Selenium # @param optional block to be invoked when element method is called # def span(name, identifier={:index => 0}, &block) define_method(name) do return platform.span_text_for identifier.clone unless block_given? self.send("#{name}_element").text end define_method("#{name}_element") do return call_block(&block) if block_given? platform.span_for(identifier.clone) end define_method("#{name}?") do return call_block(&block).exists? if block_given? platform.span_for(identifier.clone).exists? end alias_method "#{name}_span".to_sym, "#{name}_element".to_sym end # # adds three methods - one to return the text for the table, one # to retrieve the table element, and another to # check the table's existence. The existence method does not work # on Selenium so it should not be called. # # @example # table(:cart, :id => 'shopping_cart') # # will generate a 'cart', 'cart_element' and 'cart?' method # # @param [Symbol] the name used for the generated methods # @param [Hash] identifier how we find a table. You can use a multiple paramaters # by combining of any of the following except xpath. The valid keys are: # * :class => Watir and Selenium # * :css => Selenium only # * :id => Watir and Selenium # * :index => Watir and Selenium # * :name => Watir and Selenium # * :xpath => Watir and Selenium # @param optional block to be invoked when element method is called # def table(name, identifier={:index => 0}, &block) define_method(name) do return platform.table_text_for identifier.clone unless block_given? self.send("#{name}_element").text end define_method("#{name}_element") do return call_block(&block) if block_given? platform.table_for(identifier.clone) end define_method("#{name}?") do return call_block(&block).exists? if block_given? platform.table_for(identifier.clone).exists? end alias_method "#{name}_table".to_sym, "#{name}_element".to_sym 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 paramaters # by combining of any of the following except xpath. The valid keys are: # * :class => Watir and Selenium # * :css => Selenium only # * :id => Watir and Selenium # * :index => Watir and Selenium # * :name => Watir and Selenium # * :text => Watir and Selenium # * :xpath => Watir and Selenium # @param optional block to be invoked when element method is called # def cell(name, identifier={:index => 0}, &block) define_method("#{name}") do return platform.cell_text_for identifier.clone unless block_given? self.send("#{name}_element").text end define_method("#{name}_element") do return call_block(&block) if block_given? platform.cell_for(identifier.clone) end define_method("#{name}?") do return call_block(&block).exists? if block_given? platform.cell_for(identifier.clone).exists? end alias_method "#{name}_cell".to_sym, "#{name}_element".to_sym end alias_method :td, :cell # # 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' and 'logo?' methods # # @param [Symbol] the name used for the generated methods # @param [Hash] identifier how we find an image. You can use a multiple paramaters # by combining of any of the following except xpath. The valid keys are: # * :alt => Watir and Selenium # * :class => Watir and Selenium # * :css => Selenium only # * :id => Watir and Selenium # * :index => Watir and Selenium # * :name => Watir and Selenium # * :src => Watir and Selenium # * :xpath => Watir and Selenium # @param optional block to be invoked when element method is called # def image(name, identifier={:index => 0}, &block) define_method("#{name}_element") do return call_block(&block) if block_given? platform.image_for(identifier.clone) end define_method("#{name}?") do return call_block(&block).exists? if block_given? platform.image_for(identifier.clone).exists? end alias_method "#{name}_image".to_sym, "#{name}_element".to_sym 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 paramaters # by combining of any of the following except xpath. The valid keys are: # * :action => Watir and Selenium # * :class => Watir and Selenium # * :css => Selenium only # * :id => Watir and Selenium # * :index => Watir and Selenium # * :xpath => Watir and Selenium # @param optional block to be invoked when element method is called # def form(name, identifier={:index => 0}, &block) define_method("#{name}_element") do return call_block(&block) if block_given? platform.form_for(identifier.clone) end define_method("#{name}?") do return call_block(&block).exists? if block_given? platform.form_for(identifier.clone).exists? end alias_method "#{name}_form".to_sym, "#{name}_element".to_sym end # # 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 paramaters # by combining of any of the following except xpath. The valid keys are: # * :class => Watir and Selenium # * :css => Selenium only # * :id => Watir and Selenium # * :index => Watir and Selenium # * :name => Watir and Selenium # * :text => Watir and Selenium # * :xpath => Watir and Selenium # @param optional block to be invoked when element method is called # def list_item(name, identifier={:index => 0}, &block) define_method(name) do return platform.list_item_text_for identifier.clone unless block_given? self.send("#{name}_element").text end define_method("#{name}_element") do return call_block(&block) if block_given? platform.list_item_for(identifier.clone) end define_method("#{name}?") do return call_block(&block).exists? if block_given? platform.list_item_for(identifier.clone).exists? end alias_method "#{name}_list_item".to_sym, "#{name}_element".to_sym end alias_method :li, :list_item # # adds three methods - one to return the text within the unorderd # list, one to 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 paramaters # by combining of any of the following except xpath. The valid keys are: # * :class => Watir and Selenium # * :css => Selenium only # * :id => Watir and Selenium # * :index => Watir and Selenium # * :name => Watir and Selenium # * :xpath => Watir and Selenium # @param optional block to be invoked when element method is called # def unordered_list(name, identifier={:index => 0}, &block) define_method(name) do return platform.unordered_list_text_for identifier.clone unless block_given? self.send("#{name}_element").text end define_method("#{name}_element") do return call_block(&block) if block_given? platform.unordered_list_for(identifier.clone) end define_method("#{name}?") do return call_block(&block).exists? if block_given? platform.unordered_list_for(identifier.clone).exists? end alias_method "#{name}_unordered_list".to_sym, "#{name}_element".to_sym end alias_method :ul, :unordered_list # # adds three methods - one to return the text withing 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 paramaters # by combining of any of the following except xpath. The valid keys are: # * :class => Watir and Selenium # * :css => Selenium only # * :id => Watir and Selenium # * :index => Watir and Selenium # * :name => Watir and Selenium # * :xpath => Watir and Selenium # @param optional block to be invoked when element method is called # def ordered_list(name, identifier={:index => 0}, &block) define_method(name) do return platform.ordered_list_text_for identifier.clone unless block_given? self.send("#{name}_element").text end define_method("#{name}_element") do return call_block(&block) if block_given? platform.ordered_list_for(identifier.clone) end define_method("#{name}?") do return call_block(&block).exists? if block_given? platform.ordered_list_for(identifier.clone).exists? end alias_method "#{name}_ordered_list".to_sym, "#{name}_element".to_sym end alias_method :ol, :ordered_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 # by combining of any of the following except xpath. The valid keys are: # * :class => Watir and Selenium # * :css => Selenium only # * :id => Watir and Selenium # * :index => Watir and Selenium # * :name => Watir and Selenium # * :xpath => Watir and Selenium # @param optional block to be invoked when element method is called # def h1(name, identifier={:index => 0}, &block) define_method(name) do return platform.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? platform.h1_for(identifier.clone) end define_method("#{name}?") do return call_block(&block).exists? if block_given? platform.h1_for(identifier.clone).exists? end alias_method "#{name}_h1".to_sym, "#{name}_element".to_sym 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 # by combining of any of the following except xpath. The valid keys are: # * :class => Watir and Selenium # * :css => Selenium only # * :id => Watir and Selenium # * :index => Watir and Selenium # * :name => Watir and Selenium # * :xpath => Watir and Selenium # @param optional block to be invoked when element method is called # def h2(name, identifier={:index => 0}, &block) define_method(name) do return platform.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? platform.h2_for(identifier.clone) end define_method("#{name}?") do return call_block(&block).exists? if block_given? platform.h2_for(identifier.clone).exists? end alias_method "#{name}_h2".to_sym, "#{name}_element".to_sym 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 # by combining of any of the following except xpath. The valid keys are: # * :class => Watir and Selenium # * :css => Selenium only # * :id => Watir and Selenium # * :index => Watir and Selenium # * :name => Watir and Selenium # * :xpath => Watir and Selenium # @param optional block to be invoked when element method is called # def h3(name, identifier={:index => 0}, &block) define_method(name) do return platform.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? platform.h3_for(identifier.clone) end define_method("#{name}?") do return call_block(&block).exists? if block_given? platform.h3_for(identifier.clone).exists? end alias_method "#{name}_h3".to_sym, "#{name}_element".to_sym 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 # by combining of any of the following except xpath. The valid keys are: # * :class => Watir and Selenium # * :css => Selenium only # * :id => Watir and Selenium # * :index => Watir and Selenium # * :name => Watir and Selenium # * :xpath => Watir and Selenium # @param optional block to be invoked when element method is called # def h4(name, identifier={:index => 0}, &block) define_method(name) do return platform.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? platform.h4_for(identifier.clone) end define_method("#{name}?") do return call_block(&block).exists? if block_given? platform.h4_for(identifier.clone).exists? end alias_method "#{name}_h4".to_sym, "#{name}_element".to_sym 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 # by combining of any of the following except xpath. The valid keys are: # * :class => Watir and Selenium # * :css => Selenium only # * :id => Watir and Selenium # * :index => Watir and Selenium # * :name => Watir and Selenium # * :xpath => Watir and Selenium # @param optional block to be invoked when element method is called # def h5(name, identifier={:index => 0}, &block) define_method(name) do return platform.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? platform.h5_for(identifier.clone) end define_method("#{name}?") do return call_block(&block).exists? if block_given? platform.h5_for(identifier.clone).exists? end alias_method "#{name}_h5".to_sym, "#{name}_element".to_sym 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 # by combining of any of the following except xpath. The valid keys are: # * :class => Watir and Selenium # * :css => Selenium only # * :id => Watir and Selenium # * :index => Watir and Selenium # * :name => Watir and Selenium # * :xpath => Watir and Selenium # @param optional block to be invoked when element method is called # def h6(name, identifier={:index => 0}, &block) define_method(name) do return platform.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? platform.h6_for(identifier.clone) end define_method("#{name}?") do return call_block(&block).exists? if block_given? platform.h6_for(identifier.clone).exists? end alias_method "#{name}_h6".to_sym, "#{name}_element".to_sym 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 # by combining of any of the following except xpath. The valid keys are: # * :class => Watir and Selenium # * :css => Selenium only # * :id => Watir and Selenium # * :index => Watir and Selenium # * :name => Watir and Selenium # * :xpath => Watir and Selenium # @param optional block to be invoked when element method is called # def paragraph(name, identifier={:index => 0}, &block) define_method(name) do return platform.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? platform.paragraph_for(identifier.clone) end define_method("#{name}?") do return call_block(&block).exists? if block_given? platform.paragraph_for(identifier.clone).exists? end alias_method "#{name}_paragraph".to_sym, "#{name}_element".to_sym 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 # by combining of any of the following except xpath. The valid keys are: # * :class => Watir and Selenium # * :css => Selenium only # * :id => Watir and Selenium # * :index => Watir and Selenium # * :name => Watir and Selenium # * :title => Watir and Selenium # * :xpath => Watir and Selenium # @param optional block to be invoked when element method is called # def file_field(name, identifier={:index => 0}, &block) define_method("#{name}=") do |value| return platform.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? platform.file_field_for(identifier.clone) end define_method("#{name}?") do return call_block(&block).exists? if block_given? platform.file_field_for(identifier.clone).exists? 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 paramaters # by combining of any of the following except xpath. The valid keys are: # * :class => Watir and Selenium # * :css => Selenium only # * :id => Watir and Selenium # * :index => Watir and Selenium # * :name => Watir and Selenium # * :text => Watir and Selenium # * :xpath => Watir and Selenium # @param optional block to be invoked when element method is called # def label(name, identifier={:index => 0}, &block) define_method(name) do return platform.label_text_for identifier.clone unless block_given? self.send("#{name}_element").text end define_method("#{name}_element") do return call_block(&block) if block_given? platform.label_for(identifier.clone) end define_method("#{name}?") do return call_block(&block).exists? if block_given? platform.label_for(identifier.clone).exists? end alias_method "#{name}_label".to_sym, "#{name}_element".to_sym 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 paramaters # by combining of any of the following except xpath. The valid keys are: # * :class => Watir and Selenium # * :css => Selenium only # * :id => Watir and Selenium # * :index => Watir and Selenium # * :name => Watir and Selenium # * :text => Watir and Selenium # * :xpath => Watir and Selenium # @param optional block to be invoked when element method is called # def area(name, identifier={:index => 0}, &block) define_method(name) do return platform.click_area_for identifier.clone unless block_given? self.send("#{name}_element").click end define_method("#{name}_element") do return call_block(&block) if block_given? platform.area_for(identifier.clone) end define_method("#{name}?") do return call_block(&block).exists? if block_given? platform.area_for(identifier.clone).exists? end end # # adds two methods - 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 paramaters # by combining of any of the following except xpath. The valid keys are: # * :class => Watir and Selenium # * :css => Selenium only # * :id => Watir and Selenium # * :index => Watir and Selenium # * :name => Watir and Selenium # * :xpath => Watir and Selenium # @param optional block to be invoked when element method is called # def canvas(name, identifier={:index => 0}, &block) define_method("#{name}_element") do return call_block(&block) if block_given? platform.canvas_for(identifier.clone) end define_method("#{name}?") do return call_block(&block).exists? if block_given? platform.canvas_for(identifier.clone).exists? end 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 paramaters # by combining of any of the following except xpath. The valid keys are: # * :class => Watir and Selenium # * :css => Selenium only # * :id => Watir and Selenium # * :index => Watir and Selenium # * :name => Watir and Selenium # * :xpath => Watir and Selenium # @param optional block to be invoked when element method is called # def audio(name, identifier={:index => 0}, &block) define_method("#{name}_element") do return call_block(&block) if block_given? platform.audio_for(identifier.clone) end define_method("#{name}?") do return call_block(&block).exists? if block_given? platform.audio_for(identifier.clone).exists? end 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 paramaters # by combining of any of the following except xpath. The valid keys are: # * :class => Watir and Selenium # * :css => Selenium only # * :id => Watir and Selenium # * :index => Watir and Selenium # * :name => Watir and Selenium # * :xpath => Watir and Selenium # @param optional block to be invoked when element method is called # def video(name, identifier={:index => 0}, &block) define_method("#{name}_element") do return call_block(&block) if block_given? platform.video_for(identifier.clone) end define_method("#{name}?") do return call_block(&block).exists? if block_given? platform.video_for(identifier.clone).exists? end end # # adds three methods - one to retrieve the text of an element, another # to retrieve an element, and another to check the element's existence. # # @example # element(:title, :header, :id => 'title') # # will generate 'title', 'title_element', and 'title?' methods # # @param [Symbol] the name used for the generated methods # @param [Symbol] the name of the tag for the element # @param [Hash] identifier how we find an element. You can use a multiple paramaters # by combining of any of the following except xpath. The valid keys are: # * :class => Watir and Selenium # * :css => Selenium only # * :id => Watir and Selenium # * :index => Watir and Selenium # * :name => Watir and Selenium # * :xpath => Watir and Selenium # @param optional block to be invoked when element method is called # def element(name, tag, identifier={:index => 0}, &block) define_method("#{name}") do self.send("#{name}_element").text end define_method("#{name}_element") do return call_block(&block) if block_given? platform.element_for(tag, identifier.clone) end define_method("#{name}?") do self.send("#{name}_element").exists? end end # # adds three methods - one to retrieve the text of an abbr, another # to retrieve an abbr, and another to check the abbr's existence. # # @example # abbr(: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 an abbr. You can use a multiple paramaters # by combining of any of the following except xpath. The valid keys are: # * :class => Watir and Selenium # * :css => Selenium only # * :id => Watir and Selenium # * :index => Watir and Selenium # * :name => Watir and Selenium # * :xpath => Watir and Selenium # @param optional block to be invoked when abbr method is called # def abbr(name, identifier={:index => 0}, &block) element(name, :abbr, identifier, &block) end # # adds three methods - one to retrieve the text of an address, another # to retrieve an address, and another to check the address's existence. # # @example # address(: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 an address. You can use a multiple paramaters # by combining of any of the following except xpath. The valid keys are: # * :class => Watir and Selenium # * :css => Selenium only # * :id => Watir and Selenium # * :index => Watir and Selenium # * :name => Watir and Selenium # * :xpath => Watir and Selenium # @param optional block to be invoked when address method is called # def address(name, identifier={:index => 0}, &block) element(name, :address, identifier, &block) end # # adds three methods - one to retrieve the text of an article, another # to retrieve an article, and another to check the article's existence. # # @example # article(: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 an article. You can use a multiple paramaters # by combining of any of the following except xpath. The valid keys are: # * :class => Watir and Selenium # * :css => Selenium only # * :id => Watir and Selenium # * :index => Watir and Selenium # * :name => Watir and Selenium # * :xpath => Watir and Selenium # @param optional block to be invoked when article method is called # def article(name, identifier={:index => 0}, &block) element(name, :article, identifier, &block) end # # adds three methods - one to retrieve the text of an aside, another # to retrieve an aside, and another to check the aside's existence. # # @example # aside(: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 an aside. You can use a multiple paramaters # by combining of any of the following except xpath. The valid keys are: # * :class => Watir and Selenium # * :css => Selenium only # * :id => Watir and Selenium # * :index => Watir and Selenium # * :name => Watir and Selenium # * :xpath => Watir and Selenium # @param optional block to be invoked when aside method is called # def aside(name, identifier={:index => 0}, &block) element(name, :aside, identifier, &block) end # # adds three methods - one to retrieve the text of an bdi, another # to retrieve an bdi, and another to check the bdi's existence. # # @example # bdi(: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 an bdi. You can use a multiple paramaters # by combining of any of the following except xpath. The valid keys are: # * :class => Watir and Selenium # * :css => Selenium only # * :id => Watir and Selenium # * :index => Watir and Selenium # * :name => Watir and Selenium # * :xpath => Watir and Selenium # @param optional block to be invoked when bdi method is called # def bdi(name, identifier={:index => 0}, &block) element(name, :bdi, identifier, &block) end # # adds three methods - one to retrieve the text of an bdo, another # to retrieve an bdo, and another to check the bdo's existence. # # @example # bdo(: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 an bdo. You can use a multiple paramaters # by combining of any of the following except xpath. The valid keys are: # * :class => Watir and Selenium # * :css => Selenium only # * :id => Watir and Selenium # * :index => Watir and Selenium # * :name => Watir and Selenium # * :xpath => Watir and Selenium # @param optional block to be invoked when bdo method is called # def bdo(name, identifier={:index => 0}, &block) element(name, :bdo, identifier, &block) end # # adds three methods - one to retrieve the text of an cite, another # to retrieve an cite, and another to check the cite's existence. # # @example # cite(: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 an cite. You can use a multiple paramaters # by combining of any of the following except xpath. The valid keys are: # * :class => Watir and Selenium # * :css => Selenium only # * :id => Watir and Selenium # * :index => Watir and Selenium # * :name => Watir and Selenium # * :xpath => Watir and Selenium # @param optional block to be invoked when cite method is called # def cite(name, identifier={:index => 0}, &block) element(name, :cite, identifier, &block) end # # adds three methods - one to retrieve the text of an code, another # to retrieve an code, and another to check the code's existence. # # @example # code(: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 an code. You can use a multiple paramaters # by combining of any of the following except xpath. The valid keys are: # * :class => Watir and Selenium # * :css => Selenium only # * :id => Watir and Selenium # * :index => Watir and Selenium # * :name => Watir and Selenium # * :xpath => Watir and Selenium # @param optional block to be invoked when code method is called # def code(name, identifier={:index => 0}, &block) element(name, :code, identifier, &block) end # # adds three methods - one to retrieve the text of an dd, another # to retrieve an dd, and another to check the dd's existence. # # @example # dd(: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 an dd. You can use a multiple paramaters # by combining of any of the following except xpath. The valid keys are: # * :class => Watir and Selenium # * :css => Selenium only # * :id => Watir and Selenium # * :index => Watir and Selenium # * :name => Watir and Selenium # * :xpath => Watir and Selenium # @param optional block to be invoked when dd method is called # def dd(name, identifier={:index => 0}, &block) element(name, :dd, identifier, &block) end # # adds three methods - one to retrieve the text of an dfn, another # to retrieve an dfn, and another to check the dfn's existence. # # @example # dfn(: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 an dfn. You can use a multiple paramaters # by combining of any of the following except xpath. The valid keys are: # * :class => Watir and Selenium # * :css => Selenium only # * :id => Watir and Selenium # * :index => Watir and Selenium # * :name => Watir and Selenium # * :xpath => Watir and Selenium # @param optional block to be invoked when dfn method is called # def dfn(name, identifier={:index => 0}, &block) element(name, :dfn, identifier, &block) end # # adds three methods - one to retrieve the text of an dt, another # to retrieve an dt, and another to check the dt's existence. # # @example # dt(: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 an dt. You can use a multiple paramaters # by combining of any of the following except xpath. The valid keys are: # * :class => Watir and Selenium # * :css => Selenium only # * :id => Watir and Selenium # * :index => Watir and Selenium # * :name => Watir and Selenium # * :xpath => Watir and Selenium # @param optional block to be invoked when dt method is called # def dt(name, identifier={:index => 0}, &block) element(name, :dt, identifier, &block) end # # adds three methods - one to retrieve the text of an em, another # to retrieve an em, and another to check the em's existence. # # @example # em(: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 an em. You can use a multiple paramaters # by combining of any of the following except xpath. The valid keys are: # * :class => Watir and Selenium # * :css => Selenium only # * :id => Watir and Selenium # * :index => Watir and Selenium # * :name => Watir and Selenium # * :xpath => Watir and Selenium # @param optional block to be invoked when em method is called # def em(name, identifier={:index => 0}, &block) element(name, :em, identifier, &block) end # # adds three methods - one to retrieve the text of an figcaption, another # to retrieve an figcaption, and another to check the figcaption's existence. # # @example # figcaption(:title, :id => 'title') # # will generate 'title', 'title_elfigcaptionent', and 'title?' methods # # @param [Symbol] the name used for the generated methods # @param [Hash] identifier how we find an figcaption. You can use a multiple paramaters # by combining of any of the following except xpath. The valid keys are: # * :class => Watir and Selenium # * :css => Selenium only # * :id => Watir and Selenium # * :index => Watir and Selenium # * :name => Watir and Selenium # * :xpath => Watir and Selenium # @param optional block to be invoked when figcaption method is called # def figcaption(name, identifier={:index => 0}, &block) element(name, :figcaption, identifier, &block) end # # adds three methods - one to retrieve the text of an figure, another # to retrieve an figure, and another to check the figure's existence. # # @example # figure(:title, :id => 'title') # # will generate 'title', 'title_elfigureent', and 'title?' methods # # @param [Symbol] the name used for the generated methods # @param [Hash] identifier how we find an figure. You can use a multiple paramaters # by combining of any of the following except xpath. The valid keys are: # * :class => Watir and Selenium # * :css => Selenium only # * :id => Watir and Selenium # * :index => Watir and Selenium # * :name => Watir and Selenium # * :xpath => Watir and Selenium # @param optional block to be invoked when figure method is called # def figure(name, identifier={:index => 0}, &block) element(name, :figure, identifier, &block) end # # adds three methods - one to retrieve the text of an footer, another # to retrieve an footer, and another to check the footer's existence. # # @example # footer(:title, :id => 'title') # # will generate 'title', 'title_elfooterent', and 'title?' methods # # @param [Symbol] the name used for the generated methods # @param [Hash] identifier how we find an footer. You can use a multiple paramaters # by combining of any of the following except xpath. The valid keys are: # * :class => Watir and Selenium # * :css => Selenium only # * :id => Watir and Selenium # * :index => Watir and Selenium # * :name => Watir and Selenium # * :xpath => Watir and Selenium # @param optional block to be invoked when footer method is called # def footer(name, identifier={:index => 0}, &block) element(name, :footer, identifier, &block) end # # adds three methods - one to retrieve the text of an header, another # to retrieve an header, and another to check the header's existence. # # @example # header(:title, :id => 'title') # # will generate 'title', 'title_elheaderent', and 'title?' methods # # @param [Symbol] the name used for the generated methods # @param [Hash] identifier how we find an header. You can use a multiple paramaters # by combining of any of the following except xpath. The valid keys are: # * :class => Watir and Selenium # * :css => Selenium only # * :id => Watir and Selenium # * :index => Watir and Selenium # * :name => Watir and Selenium # * :xpath => Watir and Selenium # @param optional block to be invoked when header method is called # def header(name, identifier={:index => 0}, &block) element(name, :header, identifier, &block) end # # adds three methods - one to retrieve the text of an hgroup, another # to retrieve an hgroup, and another to check the hgroup's existence. # # @example # hgroup(:title, :id => 'title') # # will generate 'title', 'title_elhgroupent', and 'title?' methods # # @param [Symbol] the name used for the generated methods # @param [Hash] identifier how we find an hgroup. You can use a multiple paramaters # by combining of any of the following except xpath. The valid keys are: # * :class => Watir and Selenium # * :css => Selenium only # * :id => Watir and Selenium # * :index => Watir and Selenium # * :name => Watir and Selenium # * :xpath => Watir and Selenium # @param optional block to be invoked when hgroup method is called # def hgroup(name, identifier={:index => 0}, &block) element(name, :hgroup, identifier, &block) end # # adds three methods - one to retrieve the text of an kbd, another # to retrieve an kbd, and another to check the kbd's existence. # # @example # kbd(:title, :id => 'title') # # will generate 'title', 'title_elkbdent', and 'title?' methods # # @param [Symbol] the name used for the generated methods # @param [Hash] identifier how we find an kbd. You can use a multiple paramaters # by combining of any of the following except xpath. The valid keys are: # * :class => Watir and Selenium # * :css => Selenium only # * :id => Watir and Selenium # * :index => Watir and Selenium # * :name => Watir and Selenium # * :xpath => Watir and Selenium # @param optional block to be invoked when kbd method is called # def kbd(name, identifier={:index => 0}, &block) element(name, :kbd, identifier, &block) end # # adds three methods - one to retrieve the text of an mark, another # to retrieve an mark, and another to check the mark's existence. # # @example # mark(:title, :id => 'title') # # will generate 'title', 'title_elmarkent', and 'title?' methods # # @param [Symbol] the name used for the generated methods # @param [Hash] identifier how we find an mark. You can use a multiple paramaters # by combining of any of the following except xpath. The valid keys are: # * :class => Watir and Selenium # * :css => Selenium only # * :id => Watir and Selenium # * :index => Watir and Selenium # * :name => Watir and Selenium # * :xpath => Watir and Selenium # @param optional block to be invoked when mark method is called # def mark(name, identifier={:index => 0}, &block) element(name, :mark, identifier, &block) end # # adds three methods - one to retrieve the text of an nav, another # to retrieve an nav, and another to check the nav's existence. # # @example # nav(:title, :id => 'title') # # will generate 'title', 'title_elnavent', and 'title?' methods # # @param [Symbol] the name used for the generated methods # @param [Hash] identifier how we find an nav. You can use a multiple paramaters # by combining of any of the following except xpath. The valid keys are: # * :class => Watir and Selenium # * :css => Selenium only # * :id => Watir and Selenium # * :index => Watir and Selenium # * :name => Watir and Selenium # * :xpath => Watir and Selenium # @param optional block to be invoked when nav method is called # def nav(name, identifier={:index => 0}, &block) element(name, :nav, identifier, &block) end # # adds three methods - one to retrieve the text of an noscript, another # to retrieve an noscript, and another to check the noscript's existence. # # @example # noscript(:title, :id => 'title') # # will generate 'title', 'title_elnoscriptent', and 'title?' methods # # @param [Symbol] the name used for the generated methods # @param [Hash] identifier how we find an noscript. You can use a multiple paramaters # by combining of any of the following except xpath. The valid keys are: # * :class => Watir and Selenium # * :css => Selenium only # * :id => Watir and Selenium # * :index => Watir and Selenium # * :name => Watir and Selenium # * :xpath => Watir and Selenium # @param optional block to be invoked when noscript method is called # def noscript(name, identifier={:index => 0}, &block) element(name, :noscript, identifier, &block) end # # adds three methods - one to retrieve the text of an rp, another # to retrieve an rp, and another to check the rp's existence. # # @example # rp(:title, :id => 'title') # # will generate 'title', 'title_elrpent', and 'title?' methods # # @param [Symbol] the name used for the generated methods # @param [Hash] identifier how we find an rp. You can use a multiple paramaters # by combining of any of the following except xpath. The valid keys are: # * :class => Watir and Selenium # * :css => Selenium only # * :id => Watir and Selenium # * :index => Watir and Selenium # * :name => Watir and Selenium # * :xpath => Watir and Selenium # @param optional block to be invoked when rp method is called # def rp(name, identifier={:index => 0}, &block) element(name, :rp, identifier, &block) end # # adds three methods - one to retrieve the text of an rt, another # to retrieve an rt, and another to check the rt's existence. # # @example # rt(:title, :id => 'title') # # will generate 'title', 'title_elrtent', and 'title?' methods # # @param [Symbol] the name used for the generated methods # @param [Hash] identifier how we find an rt. You can use a multiple paramaters # by combining of any of the following except xpath. The valid keys are: # * :class => Watir and Selenium # * :css => Selenium only # * :id => Watir and Selenium # * :index => Watir and Selenium # * :name => Watir and Selenium # * :xpath => Watir and Selenium # @param optional block to be invoked when rt method is called # def rt(name, identifier={:index => 0}, &block) element(name, :rt, identifier, &block) end # # adds three methods - one to retrieve the text of an ruby, another # to retrieve an ruby, and another to check the ruby's existence. # # @example # ruby(:title, :id => 'title') # # will generate 'title', 'title_elrubyent', and 'title?' methods # # @param [Symbol] the name used for the generated methods # @param [Hash] identifier how we find an ruby. You can use a multiple paramaters # by combining of any of the following except xpath. The valid keys are: # * :class => Watir and Selenium # * :css => Selenium only # * :id => Watir and Selenium # * :index => Watir and Selenium # * :name => Watir and Selenium # * :xpath => Watir and Selenium # @param optional block to be invoked when ruby method is called # def ruby(name, identifier={:index => 0}, &block) element(name, :ruby, identifier, &block) end # # adds three methods - one to retrieve the text of an samp, another # to retrieve an samp, and another to check the samp's existence. # # @example # samp(:title, :id => 'title') # # will generate 'title', 'title_elsampent', and 'title?' methods # # @param [Symbol] the name used for the generated methods # @param [Hash] identifier how we find an samp. You can use a multiple paramaters # by combining of any of the following except xpath. The valid keys are: # * :class => Watir and Selenium # * :css => Selenium only # * :id => Watir and Selenium # * :index => Watir and Selenium # * :name => Watir and Selenium # * :xpath => Watir and Selenium # @param optional block to be invoked when samp method is called # def samp(name, identifier={:index => 0}, &block) element(name, :samp, identifier, &block) end # # adds three methods - one to retrieve the text of an section, another # to retrieve an section, and another to check the section's existence. # # @example # section(:title, :id => 'title') # # will generate 'title', 'title_elsectionent', and 'title?' methods # # @param [Symbol] the name used for the generated methods # @param [Hash] identifier how we find an section. You can use a multiple paramaters # by combining of any of the following except xpath. The valid keys are: # * :class => Watir and Selenium # * :css => Selenium only # * :id => Watir and Selenium # * :index => Watir and Selenium # * :name => Watir and Selenium # * :xpath => Watir and Selenium # @param optional block to be invoked when section method is called # def section(name, identifier={:index => 0}, &block) element(name, :section, identifier, &block) end # # adds three methods - one to retrieve the text of an sub, another # to retrieve an sub, and another to check the sub's existence. # # @example # sub(:title, :id => 'title') # # will generate 'title', 'title_elsubent', and 'title?' methods # # @param [Symbol] the name used for the generated methods # @param [Hash] identifier how we find an sub. You can use a multiple paramaters # by combining of any of the following except xpath. The valid keys are: # * :class => Watir and Selenium # * :css => Selenium only # * :id => Watir and Selenium # * :index => Watir and Selenium # * :name => Watir and Selenium # * :xpath => Watir and Selenium # @param optional block to be invoked when sub method is called # def sub(name, identifier={:index => 0}, &block) element(name, :sub, identifier, &block) end # # adds three methods - one to retrieve the text of an summary, another # to retrieve an summary, and another to check the summary's existence. # # @example # summary(:title, :id => 'title') # # will generate 'title', 'title_elsummaryent', and 'title?' methods # # @param [Symbol] the name used for the generated methods # @param [Hash] identifier how we find an summary. You can use a multiple paramaters # by combining of any of the following except xpath. The valid keys are: # * :class => Watir and Selenium # * :css => Selenium only # * :id => Watir and Selenium # * :index => Watir and Selenium # * :name => Watir and Selenium # * :xpath => Watir and Selenium # @param optional block to be invoked when summary method is called # def summary(name, identifier={:index => 0}, &block) element(name, :summary, identifier, &block) end # # adds three methods - one to retrieve the text of an sup, another # to retrieve an sup, and another to check the sup's existence. # # @example # sup(:title, :id => 'title') # # will generate 'title', 'title_elsupent', and 'title?' methods # # @param [Symbol] the name used for the generated methods # @param [Hash] identifier how we find an sup. You can use a multiple paramaters # by combining of any of the following except xpath. The valid keys are: # * :class => Watir and Selenium # * :css => Selenium only # * :id => Watir and Selenium # * :index => Watir and Selenium # * :name => Watir and Selenium # * :xpath => Watir and Selenium # @param optional block to be invoked when sup method is called # def sup(name, identifier={:index => 0}, &block) element(name, :sup, identifier, &block) end # # adds three methods - one to retrieve the text of an var, another # to retrieve an var, and another to check the var's existence. # # @example # var(:title, :id => 'title') # # will generate 'title', 'title_elvarent', and 'title?' methods # # @param [Symbol] the name used for the generated methods # @param [Hash] identifier how we find an var. You can use a multiple paramaters # by combining of any of the following except xpath. The valid keys are: # * :class => Watir and Selenium # * :css => Selenium only # * :id => Watir and Selenium # * :index => Watir and Selenium # * :name => Watir and Selenium # * :xpath => Watir and Selenium # @param optional block to be invoked when var method is called # def var(name, identifier={:index => 0}, &block) element(name, :var, identifier, &block) end # # adds three methods - one to retrieve the text of an wbr, another # to retrieve an wbr, and another to check the wbr's existence. # # @example # wbr(:title, :id => 'title') # # will generate 'title', 'title_elwbrent', and 'title?' methods # # @param [Symbol] the name used for the generated methods # @param [Hash] identifier how we find an wbr. You can use a multiple paramaters # by combining of any of the following except xpath. The valid keys are: # * :class => Watir and Selenium # * :css => Selenium only # * :id => Watir and Selenium # * :index => Watir and Selenium # * :name => Watir and Selenium # * :xpath => Watir and Selenium # @param optional block to be invoked when wbr method is called # def wbr(name, identifier={:index => 0}, &block) element(name, :wbr, identifier, &block) end # # adds a method that will return an indexed property. The property will respond to # the [] method with an object that has a set of normal page_object properties that # correspond to the definitions included in the identifier_list parameter, with the # "what" of the "how and what" substituted based on the index provided to the [] # method. # # @example # indexed_property(:title, [ # [:text_field, :field_1, :id => 'table[%s].field_1'], # [:button, :button_1, :id => 'table[%s].button_1'], # [:text_field, :field_2, :name => 'table[%s].field_2'] # ]) # # will generate a title method that responds to []. title['foo'] will return an object # # that responds to the normal methods expected for two text_fields and a button with the # # given names, using the given how and what with 'foo' substituted for the %s. title[123] # # will do the same, using the integer 123 instead. # # @param [Symbol] the name used for the generated method # @param [Array] definitions an array of definitions to define on the indexed property. Each # entry in the array should contain two symbols and a hash, corresponding to one of the standard # page_object properties with a single substitution marker in each value in the hash, # e.g. [:text_field, :field_1, :id => 'table[%s].field_1'] # def indexed_property (name, identifier_list) define_method("#{name}") do IndexedProperties::TableOfElements.new(@browser, identifier_list) end end # # methods to fetch multiple elements of the same type # # adds a method to the page object to retrun all of the matching elements # # @example # text_fields(:first_name, :id => "first_name") # # will generate 'first_name_elements' # # @param [String] the name used for the generated methods # @param [Hash] identifier how we find a text field. You can use a multiple paramaters # by combining of any of the following except xpath. The valid # keys are the same ones supported by the standard methods. # @param optional block to be invoked when element method is called # [:text_fields, :hidden_fields, :text_areas, :select_lists, :links, :checkboxes, :radio_buttons, :buttons, :divs, :spans, :tables, :cells, :images, :forms, :list_items, :unordered_lists, :ordered_lists, :h1s, :h2s, :h3s, :h4s, :h5s, :h6s, :paragraphs, :labels, :file_fields].each do |method_name| define_method(method_name) do |name, identifier, &block| define_method("#{name}_elements") do return call_block(&block) if block_given? platform.send "#{method_name.to_s}_for", identifier.clone end end end end end