page_object_wrapper 0.0.6 → 1.0.0

data/bad_pages/bad_page.rb

@@ -0,0 +1,34 @@
+require 'page_object_wrapper'
+
+PageObjectWrapper.define_page('some_page_with_lost_of_errors') do
+  locator ''
+  uniq_element 'uniq element locator'
+
+  elements_set('some elements_set label') do
+  end
+
+  elements_set(:bad_elements) do
+    element('') do
+    end
+    element(:e) do
+      locator ':e element locator'
+    end
+    element(:e) do
+      locator Hash.new
+    end
+  end
+
+  action('',nil) do
+  end
+
+  table('') do
+  end
+  table(:some_table) do
+    header []
+  end
+
+  pagination('') do
+    locator 'pagination locator'
+  end
+end
+

data/good_pages/another_test_page.rb

@@ -0,0 +1,14 @@
+require 'page_object_wrapper'
+PageObjectWrapper.define_page(:another_test_page) do
+  locator 'http://www.cs.tut.fi/~jkorpela/www/testel.html'
+  uniq_h1 :text => 'Testing display of HTML elements'
+
+  elements_set(:test_elements) do
+    select(:s1) do
+      locator :id => 'f10'
+      fresh_food 'not in select list'
+      missing_food 'not in select list'
+    end
+  end
+end
+

data/good_pages/some_test_page.rb

@@ -0,0 +1,53 @@
+require 'page_object_wrapper'
+PageObjectWrapper.define_page(:some_test_page) do
+  locator 'http://www.cs.tut.fi/~jkorpela/www/testel.html'
+  uniq_h1 :text => 'Testing display of HTML elements'
+
+  elements_set(:test_elements) do
+    text_field(:tf) do
+      locator :id => 'f1'
+      missing_food 'some missing food'
+      fresh_food 'some fresh food'
+    end
+
+    textarea(:ta) do
+      locator :id => 'f2'
+    end
+    
+    select(:s1) do
+      locator :id => 'f10'
+      fresh_food 'one'
+      missing_food 'three'
+    end
+
+    select(:s2) do
+      locator :id => 'f11'
+      fresh_food 'one'
+    end
+
+    checkbox(:cb){ locator :id => 'f5' }
+    radio(:rb){ locator :id => 'f3' }
+  end
+
+  action(:press_cool_button, :test_page_with_table) do
+    button(:name => 'foo').when_present.click
+  end
+
+  action(:fill_textarea, :some_test_page) do |fill_with|
+    data = (fill_with.empty?)? 'Default data' : fill_with
+    textarea(:id => 'f2').set data
+  end
+
+  table(:table_without_header) do
+    locator :summary => 'Each row names a Nordic country and specifies its total area and land area, in square kilometers'
+  end
+
+  table(:table_with_header) do
+    locator :summary => 'Each row names a Nordic country and specifies its total area and land area, in square kilometers'
+    header [:country, :total_area, :land_area]
+  end
+
+  pagination(:some_pagination) do
+    locator :xpath => ''
+  end
+end

data/good_pages/test_table_page.rb

@@ -0,0 +1,12 @@
+require 'page_object_wrapper'
+PageObjectWrapper.define_page(:test_page_with_table) do
+  locator 'http://www.cs.tut.fi/cgi-bin/run/~jkorpela/echo.cgi?hidden+field=42&foo=bar&text=Default+text.&textarea=Default+text.%0D%0A&radio=2&checkbox2=on&select1=two+%28default%29&select2=two+%28default%29'
+  uniq_h1 :text => 'Echoing submitted form data'
+
+  table(:test_table) do
+    locator :index => 0
+  end
+
+  elements_set(:empty_set) do
+  end
+end

data/lib/page_object_wrapper.rb

@@ -1,99 +1,64 @@
 # -*- encoding : utf-8 -*-
 require "watir-webdriver"
 require "version"
-require 'Exceptions'
-require 'Form'
-require 'Table'
-require 'Pagination'
-require 'DynamicClass'
+require 'PageObject'
 
 module PageObjectWrapper
 
-	class TestData < DynamicClass; end
-
-	def self.start_browser b=nil
-		Page.accessor = (b.nil?)? Watir::Browser.new : b
-		Page.accessor.driver.manage.timeouts.implicit_wait=3
-		Page.accessor.driver.manage.timeouts.page_load=30
-		Page.accessor.driver.manage.timeouts.script_timeout=30
-	end
-
-	def self.stop_browser
-		Page.accessor.quit
-	end
-
-	def self.restart_browser
-		self.stop_browser
-		self.start_browser
-	end
-
-	def self.domain=(val)
-		Page.base_url = val
-	end
-
-	class Page
-		class << self
-			attr_accessor :url, :expected_elements, :full_url
-		end
-
-		@@base_url = ''
-		@@accessor = nil
-		@url = ''
-		@expected_elements = {}
-
-		def initialize visit = false
-			self.class.full_url = @@base_url + self.class.url
-			@@accessor.goto self.class.full_url if visit		
-
-			if not self.class.expected_elements.nil? 
-				if not (self.class.expected_elements.empty?)
-					self.class.expected_elements.each{|element_type, identifier|
-						begin
-							@@accessor.send(element_type,identifier).wait_until_present
-						rescue
-							raise PageError.new("expected_element #{element_type}, #{identifier.inspect} not found after a set timeout",self.class,self.class.full_url)
-						end
-					}
-				end
-			end
-		end
-
-		def self.base_url=(val)
-			@@base_url = val
-		end
-
-		def self.base_url
-			@@base_url
-		end
-
-		def self.accessor
-			@@accessor
-		end
-
-		def self.accessor=(val)
-			@@accessor = val
-		end
-		def self.expected_element(element_type,identifier)
-			self.expected_elements = {} if self.expected_elements.nil?
-			self.expected_elements[element_type] = identifier
-		end
-
-		def form(target_page,*args)
-			Form.new(self.class,target_page,@@accessor,*args)
-		end
-
-		def table(*args)
-			Table.new(@@accessor,*args)
-		end
-
-		def paginate(div_args)
-			Pagination.new(self,div_args)
-		end
-
-		def has_warning?(text)
-			@@accessor.text.include?(text)
-		end
-
-		alias :has_text? :has_warning?
-	end
+  @@domain = nil
+  @@browser = nil
+
+  def self.domain=val
+    @@domain=val
+  end
+
+  def self.use_browser b
+    PageObject.browser = b
+  end
+
+  def self.browser
+    PageObject.browser
+  end
+
+  def self.define_page(label, &block)
+    page = PageObject.new(label)
+    page.instance_eval(&block)
+    PageObject.pages << page
+    page
+  end
+
+  def self.current_page
+    PageObject.current_page
+  end
+
+  def self.load(path_to_pages='.')
+    processed = 0
+    Dir.glob("#{path_to_pages}/*_page.rb"){|fn|
+      processed +=1
+      require fn
+    }
+    raise PageObjectWrapper::Load, "No *_page.rb files found in #{path_to_pages}" if processed.zero?
+    output = []
+    PageObject.pages.each{|p|
+      output += p.validate
+    }
+    raise PageObjectWrapper::Load, output.join if not output.empty?
+  end
+
+  def self.domain=val
+    @@domain = val
+  end
+
+  def self.domain
+    @@domain
+  end
+
+  def self.receive_page(label)
+    PageObject.find_page_object(label)
+  end
+
+  def self.open_page(label)
+    PageObject.open_page label
+    PageObject.map_current_page label
+  end
 end

data/lib/page_object_wrapper/Action.rb

@@ -0,0 +1,11 @@
+require 'Dsl'
+class Action < DslElement
+  attr_reader :fire_block_value, :next_page_value
+
+  def initialize(label, next_page, &block)
+    super label
+    @next_page_value = next_page
+    @fire_block_value = block
+  end
+end
+

data/lib/page_object_wrapper/Dsl.rb

@@ -0,0 +1,35 @@
+class Class
+  def dsl_attr_accessor(*args)
+    # iterate through each passed in argument...
+    args.each do |arg|
+      # getter
+      self.class_eval("def #{arg}_value;@#{arg};end")
+      # setter
+      self.class_eval("def #{arg} val;@#{arg}=val;end")
+    end
+  end
+end
+class DslElement
+  dsl_attr_accessor :label
+
+  def initialize label
+    @label = label
+  end
+protected
+  def to_tree(*args)
+    args.collect(&:label_value).join(" -> ")
+  end
+
+  def validate_label
+
+  end
+end
+
+class DslElementWithLocator < DslElement
+  dsl_attr_accessor :locator
+
+  def initialize label
+    super label
+    @locator = nil
+  end
+end

data/lib/page_object_wrapper/Element.rb

@@ -0,0 +1,15 @@
+require 'Dsl'
+class Element < DslElementWithLocator
+  attr_reader :type
+  dsl_attr_accessor :fresh_food, :missing_food
+
+  DEFAULT_FRESH_FOOD = 'default fresh food'
+  DEFAULT_MISSING_FOOD = 'default missing food'
+
+  def initialize(label, type)
+    super label
+    @type = type
+    @fresh_food = DEFAULT_FRESH_FOOD
+    @missing_food = DEFAULT_MISSING_FOOD
+  end
+end

data/lib/page_object_wrapper/ElementsSet.rb

@@ -0,0 +1,22 @@
+require 'Dsl'
+require 'known_elements'
+
+class ElementsSet < DslElement
+
+  def initialize(label)
+    super label
+    @elements = []
+  end
+
+  KNOWN_ELEMENTS.each{|m|
+    ElementsSet.send :define_method, m do |label, &block|
+      e = Element.new(label, m.to_sym)
+      e.instance_eval(&block)
+      @elements << e
+    end
+  }
+
+  def elements
+    @elements
+  end
+end

data/lib/page_object_wrapper/Exceptions.rb

@@ -1,22 +1,8 @@
-class PageError < StandardError 
-	attr_accessor :page_url, :page_name
-	def initialize(msg,page_name,page_url)
-		@page_url=page_url
-		@page_name=page_name
-		super "PROBLEM: #{(msg.nil?)? '??' : msg}, PAGE: #{page_name}, URL: #{page_url}"
-	end
-
+module PageObjectWrapper
+  class UnknownFoodType < StandardError;  end
+  class UnableToFeedObject < StandardError; end
+  class UnknownPageObject < StandardError; end
+  class UnmappedPageObject < StandardError; end
+  class Load < StandardError; end
+  class BrowserNotFound < StandardError; end
 end
-
-class ParameterError < StandardError
-	attr_accessor :method, :params
-	def initialize(msg,method,*params)
-		@method=method
-		@params=params
-		super "PROBLEM: #{(msg.nil?)? '??' : msg}, METHOD: #{method}, PARAMS: #{params.join('; ').to_s}"
-	end
-end
-
-class TableError < ParameterError; end
-class FormError < ParameterError; end
-class DynamicClassError < ParameterError; end

data/lib/page_object_wrapper/PageObject.rb

@@ -0,0 +1,371 @@
+require 'Dsl'
+require 'Exceptions'
+include PageObjectWrapper
+
+require 'ElementsSet'
+require 'Element'
+require 'Action'
+require 'Table'
+require 'Pagination'
+require 'known_elements'
+
+class PageObject < DslElementWithLocator
+  attr_reader :esets, :elements, :actions, :tables, :paginations, :uniq_element_type, :uniq_element_hash
+  @@browser = nil
+  @@pages = []
+  @@current_page = nil
+
+  FOOD_TYPES = [:missing_food, :fresh_food]
+  FEED_ALL = Regexp.new(/^feed_all$/)
+  FEED_SET = Regexp.new(/^feed_([\w_]+)$/)
+  FIRE_ACTION = Regexp.new(/^fire_([\w_]+)$/)
+  SELECT_FROM = Regexp.new(/^select_from_([\w_]+)$/)
+  PAGINATION_EACH = Regexp.new(/^([\w_]+)_each$/)
+  PAGINATION_OPEN = Regexp.new(/^([\w_]+)_open$/)
+    
+  def initialize(label)
+    super label
+    @uniq_element_type = 'element'
+    @uniq_element_hash = {}
+    @esets = []
+    @elements = []
+    @actions = []
+    @tables = []
+    @paginations = []
+  end
+
+  # lazy evaluated calls of real watir elements are handled by :method_missing
+  def method_missing(method_name, *args)
+    case 
+      when KNOWN_ELEMENTS.include?(method_name.to_s.gsub(/^uniq_/,''))
+        # page_object.uniq_xxx(hash)
+        @uniq_element_type = method_name.to_s.gsub(/^uniq_/,'').to_sym
+        @uniq_element_hash = args[0]
+      when has_eset?(method_name)
+        # page_object.some_elements_set
+        eset = eset_for(method_name)
+        return_array_of_watir_elements(eset)
+      when has_element?(method_name)
+        # page_object.some_element
+        element = element_for(method_name)
+        return_watir_element(element)
+      when FEED_ALL.match(method_name)
+        # page_object.feed_all(:fresh_food)
+        feed_elements(@elements, *args)
+      when (FEED_SET.match(method_name) and has_eset?($1))
+        # page_object.feed_some_elements_set(:fresh_food)
+        eset = eset_for($1)
+        feed_elements(eset.elements, *args)
+      when (FIRE_ACTION.match(method_name) and has_action?($1))
+        # page_object.fire_some_action
+        a = action_for($1)
+        fire_action(a, *args)
+      when (SELECT_FROM.match(method_name) and has_table?($1))
+        # page_object.select_from_some_table(:header_column, {:column => 'value'})
+        table = table_for($1)
+        select_from_table(table, *args)
+      when (PAGINATION_EACH.match(method_name) and has_pagination?($1))
+        # page_object.each_pagination
+        pagination = pagination_for($1)
+        run_each_subpage(pagination, *args)
+      when (PAGINATION_OPEN.match(method_name) and has_pagination?($1))
+        # page_object.open_padination(1)
+        pagination = pagination_for($1)
+        open_subpage(pagination, *args)
+      else
+        super
+    end
+  end
+
+  # corresponding respond_to? 
+  def respond_to?(method_sym, include_private = false)
+    method_name = method_sym.to_s
+    case 
+      when KNOWN_ELEMENTS.include?(method_name.gsub(/^uniq_/,''))
+        # page_object.uniq_xxx(hash)
+        true
+      when has_eset?(method_name)
+        # page_object.some_elements_set
+        true
+      when has_element?(method_name)
+        # page_object.some_element
+        true
+      when FEED_ALL.match(method_name)
+        # page_object.feed_all(:fresh_food)
+        true
+      when (FEED_SET.match(method_name) and has_eset?($1))
+        # page_object.feed_some_elements_set(:fresh_food)
+        true
+      when (FIRE_ACTION.match(method_name) and has_action?($1))
+        # page_object.fire_some_action
+        true
+      when (SELECT_FROM.match(method_name) and has_table?($1))
+        # page_object.select_from_some_table(:header_column, {:column => 'value'})
+        true
+      when (PAGINATION_EACH.match(method_name) and has_pagination?($1))
+        # page_object.each_pagination
+        true
+      when (PAGINATION_OPEN.match(method_name) and has_pagination?($1))
+        # page_object.open_padination(1)
+        true
+      else
+        super
+    end
+  end
+
+  def self.open_page label
+    raise PageObjectWrapper::BrowserNotFound if @@browser.nil?
+    raise PageObjectWrapper::UnknownPageObject, label if not @@pages.collect(&:label_value).include?(label)
+    page_object = PageObject.find_page_object(label)
+    url = ''
+    url += @@domain if page_object.locator_value[0]=='/'
+    url += page_object.locator_value
+    @@browser.goto url
+  end
+
+  def self.map_current_page label
+    raise PageObjectWrapper::BrowserNotFound if @@browser.nil?
+    raise PageObjectWrapper::UnknownPageObject, label if not @@pages.collect(&:label_value).include?(label)
+    page_object = PageObject.find_page_object(label)
+    watir_uniq_element = @@browser.send page_object.uniq_element_type, page_object.uniq_element_hash
+    raise PageObjectWrapper::UnmappedPageObject, "#{label} <=> #{@@browser.url}" if not watir_uniq_element.present?
+    @@current_page = page_object
+  end
+
+  def self.current_page
+    @@current_page
+  end
+
+  def self.pages
+    @@pages
+  end
+
+  def self.browser=(val)
+    @@browser = val
+  end
+
+  def self.browser
+    @@browser
+  end
+
+  def elements_set(label, &block)
+    eset = ElementsSet.new(label)
+    eset.instance_eval(&block)
+    @esets << eset
+    @elements += eset.elements
+    eset
+  end
+
+  def action(label, next_page, &block)
+    a = Action.new(label, next_page, &block)
+    @actions << a
+    a
+  end
+
+  def table(label, &block)
+    t = Table.new(label)
+    t.instance_eval(&block)
+    @tables << t
+    t
+  end
+
+
+  def pagination(label, &block)
+    p = Pagination.new(label)
+    p.instance_eval(&block)
+    @paginations << p
+    p
+  end
+
+  def validate
+    output = []
+    # commented out; already defined pages will e redifined with new definitions
+    raise PageObjectWrapper::Load, "\tpage_object #{label_value.inspect} already defined\n" if labeled(@@pages).count(label_value) > 1
+    output << "\tlabel #{label_value.inspect} not a Symbol\n" if not label_value.is_a?(Symbol)
+    output << "\tlocator #{locator_value.inspect} not a meaningful String\n" if not locator_value.is_a?(String) or locator_value.empty?
+    @esets.each{|eset|
+      eset_output = []
+      eset_output << "\telements_set #{eset.label_value.inspect} already defined\n" if labeled(@esets).count(eset.label_value) > 1
+      eset_output << "\tlabel #{eset.label_value.inspect} not a Symbol\n" if not eset.label_value.is_a?(Symbol)
+      eset_output.unshift "elements_set(#{eset.label_value.inspect}):\n" if not eset_output.empty?
+      output += eset_output
+      eset.elements.each{|e|
+        element_output = []
+        element_output << "\t\telement #{e.label_value.inspect} already defined\n" if labeled(eset.elements).count(e.label_value) > 1
+        element_output << "\t\tlabel #{e.label_value.inspect} not a Symbol\n" if not e.label_value.is_a?(Symbol)
+        element_output << "\t\tlocator #{e.locator_value.inspect} not a meaningful Hash\n" if not e.locator_value.is_a?(Hash) or e.locator_value.empty?
+        element_output.unshift "\telement(#{e.label_value.inspect}):\n" if not element_output.empty?
+        output += element_output       
+      }
+    }
+    @actions.each{|a|
+      action_output = []
+      action_output << "\taction #{a.label_value.inspect} already defined\n" if labeled(@actions).count(a.label_value) > 1
+      action_output << "\tlabel #{a.label_value.inspect} not a Symbol\n" if not a.label_value.is_a?(Symbol)
+      action_output << "\tnext_page #{a.next_page_value.inspect} not a Symbol\n" if not a.next_page_value.is_a? Symbol
+      action_output << "\tnext_page #{a.next_page_value.inspect} unknown page_object\n" if not labeled(@@pages).include?(a.next_page_value)
+      action_output << "\tfire event is not a Proc\n" if not a.fire_block_value.is_a?(Proc)
+      action_output.unshift "action(#{a.label_value.inspect}):\n" if not action_output.empty?
+      output += action_output
+    }
+    @tables.each{|t|
+      table_output = []
+      table_output << "\ttable #{t.label_value.inspect} already defined\n" if labeled(@tables).count(t.label_value) > 1
+      table_output << "\tlabel #{t.label_value.inspect} not a Symbol\n" if not t.label_value.is_a?(Symbol)
+      table_output << "\tlocator #{t.locator_value.inspect} not a meaningful Hash\n" if not t.locator_value.is_a?(Hash) or t.locator_value.empty?
+      table_output << "\theader #{t.header_value.inspect} not a meaningful Array\n" if not t.header_value.is_a?(Array) or t.header_value.empty?
+      table_output.unshift "table(#{t.label_value.inspect}):\n" if not table_output.empty?
+      output += table_output
+    }
+    @paginations.each{|p|
+      pagination_output = []
+      pagination_output << "\tpagination #{p.label_value.inspect} already defined\n" if labeled(@paginations).count(p.label_value) > 1
+      pagination_output << "\tlabel #{p.label_value.inspect} not a Symbol\n" if not p.label_value.is_a?(Symbol)
+      pagination_output << "\tlocator #{p.locator_value.inspect} not a meaningful Hash\n" if not p.locator_value.is_a?(Hash) or p.locator_value.empty?
+      pagination_output.unshift "pagination(#{p.label_value.inspect}):\n" if not pagination_output.empty?
+      output += pagination_output
+    }
+    output.unshift "page_object(#{label_value.inspect}):\n" if not output.empty?
+    output
+  end
+
+private
+
+  def self.find_page_object(l)
+    @@pages.select{|p| p.label_value == l}.first
+  end
+  
+  def return_watir_element(e)
+    @@browser.send e.type, e.locator_value
+  end
+
+  def return_array_of_watir_elements(eset)
+    eset.elements.collect{|e| @@browser.send(e.type, e.locator_value)}
+  end
+
+  def feed_elements(elements, food_type=nil)
+    raise PageObjectWrapper::BrowserNotFound if @@browser.nil? 
+    raise PageObjectWrapper::BrowserNotFound if not @@browser.exist? 
+    food_type ||= :fresh_food
+    raise PageObjectWrapper::UnknownFoodType, food_type.inspect if not FOOD_TYPES.include?(food_type)
+    elements.each{|e|
+      food = e.send (food_type.to_s+'_value').to_sym
+      watir_element = @@browser.send e.type, e.locator_value
+      case watir_element
+        when Watir::CheckBox
+          watir_element.when_present.set
+        when Watir::Radio
+          watir_element.when_present.set
+        when Watir::Select
+          begin
+            watir_element.when_present.select food
+          rescue Watir::Exception::NoValueFoundException => e
+            if food_type == :missing_food
+              # proceed to next element if missing_food is not found in select list
+              next
+            else
+              raise e
+            end
+          end
+        else
+          if watir_element.respond_to?(:set)
+            watir_element.when_present.set food
+          else
+            raise PageObjectWrapper::UnableToFeedObject, to_tree(@@current_page, eset, e)
+          end
+        end
+    }
+    self
+  end
+
+  def fire_action(a, *args)
+    raise PageObjectWrapper::BrowserNotFound if @@browser.nil?
+    @@browser.instance_exec args, &a.fire_block_value
+    self.class.map_current_page a.next_page_value
+    @@current_page
+  end
+
+  def select_from_table(table, header, where=nil)
+    raise PageObjectWrapper::BrowserNotFound if @@browser.nil?
+    t = @@browser.table(table.locator_value)
+    raise ArgumentError, "#{header.inspect} not a Symbol" if not header.is_a? Symbol
+    raise ArgumentError, "#{header.inspect} not in table header" if not table.header_value.include? header
+    search_for_index = table.header_value.index(header)
+    found = nil
+
+    if not where.nil?
+      raise ArgumentError, "#{where.inspect} not a meaningful Hash" if not where.is_a? Hash or where.empty?
+      raise ArgumentError, "#{where.inspect} has more than 1 keys" if not where.keys.length == 1
+      raise ArgumentError, "#{where.keys.first.inspect} not a Symbol" if not where.keys.first.is_a? Symbol
+      raise ArgumentError, "#{where.keys.first.inspect} not in table header" if not table.header_value.include? where.keys.first
+      raise ArgumentError, "#{where.values.first.inspect} not a String or Regexp" if not (where.values.first.is_a? String or where.values.first.is_a? Regexp)
+      search_in_index = table.header_value.index(where.keys.first)
+      search_value = where.values.first
+      t.rows.each{|r|
+        if search_value.is_a? String
+          found = r.cells[search_for_index] if r.cells[search_in_index].text == search_value
+        elsif search_value.is_a? Regexp
+          found = r.cells[search_for_index] if search_value.match(r.cells[search_in_index].text)
+        else
+          raise ArgumentError, "#{search_value} not a Regexp or String"
+        end
+      }
+    else # where == nil
+      found = t.rows.last.cells[search_for_index]
+    end
+    found
+  end
+
+  def each_pagination
+    raise PageObjectWrapper::BrowserNotFound if @@browser.nil?
+  end
+
+  def open_padination n
+    raise PageObjectWrapper::BrowserNotFound if @@browser.nil?
+  end
+
+
+  def labeled(ary)
+    ary.collect(&:label_value)
+  end
+
+  def has_eset?(label)
+    labeled(@esets).include?(label.to_sym)
+  end
+
+  def has_element?(label)
+    labeled(@elements).include?(label.to_sym)
+  end
+  
+  def has_table?(label)
+    labeled(@tables).include?(label.to_sym)
+  end
+
+  def has_pagination?(label)
+    labeled(@paginations).include?(label.to_sym)
+  end
+
+  def has_action?(label)
+    labeled(@actions).include?(label.to_sym)
+  end
+
+  def eset_for(label)
+    @esets[labeled(@esets).index(label.to_sym)]
+  end
+
+  def element_for(label)
+    @elements[labeled(@elements).index(label.to_sym)]
+  end
+
+  def table_for(label)
+    @tables[labeled(@tables).index(label.to_sym)]
+  end
+
+  def pagination_for(label)
+    @paginations[labeled(@paginations).index(label.to_sym)]
+  end
+
+  def action_for(label)
+    @actions[labeled(@actions).index(label.to_sym)]
+  end
+end