symbiont 0.1.7 → 0.1.8

data/Gemfile.lock

@@ -1,58 +1,29 @@
 PATH
   remote: .
   specs:
-    symbiont (0.1.6)
-      watir-webdriver (= 0.6.1)
+    symbiont (0.1.8)
+      selenium-webdriver (= 2.29.0)
+      watir-webdriver (= 0.6.2)
 
 GEM
   remote: http://rubygems.org/
   specs:
-    addressable (2.3.2)
-    builder (3.0.0)
-    childprocess (0.3.5)
+    childprocess (0.3.7)
       ffi (~> 1.0, >= 1.0.6)
-    cucumber (1.2.1)
-      builder (>= 2.1.2)
-      diff-lcs (>= 1.1.3)
-      gherkin (~> 2.11.0)
-      json (>= 1.4.6)
-    diff-lcs (1.1.3)
-    ffi (1.1.5)
-    ffi (1.1.5-x86-mingw32)
-    gherkin (2.11.1-x86-mingw32)
-      json (>= 1.4.6)
-    json (1.7.3)
-    libwebsocket (0.1.5)
-      addressable
-    multi_json (1.3.5)
-    rspec (2.11.0)
-      rspec-core (~> 2.11.0)
-      rspec-expectations (~> 2.11.0)
-      rspec-mocks (~> 2.11.0)
-    rspec-core (2.11.0)
-    rspec-expectations (2.11.1)
-      diff-lcs (~> 1.1.3)
-    rspec-mocks (2.11.1)
+    ffi (1.3.1-x86-mingw32)
+    multi_json (1.5.0)
     rubyzip (0.9.9)
-    selenium-webdriver (2.25.0)
+    selenium-webdriver (2.29.0)
       childprocess (>= 0.2.5)
-      libwebsocket (~> 0.1.3)
       multi_json (~> 1.0)
       rubyzip
-    simplecov (0.6.4)
-      multi_json (~> 1.0)
-      simplecov-html (~> 0.5.3)
-    simplecov-html (0.5.3)
-    watir-webdriver (0.6.1)
+      websocket (~> 1.0.4)
+    watir-webdriver (0.6.2)
       selenium-webdriver (>= 2.18.0)
-    yard (0.8.2.1)
+    websocket (1.0.7)
 
 PLATFORMS
   x86-mingw32
 
 DEPENDENCIES
-  cucumber (= 1.2.1)
-  rspec (= 2.11.0)
-  simplecov (= 0.6.4)
   symbiont!
-  yard (= 0.8.2.1)

data/HISTORY.md

@@ -1,6 +1,12 @@
 Change Log and History
 ======================
 
+Version 0.1.8 / 2013-01-30
+--------------------------
+
+This release made a lot of internal changes in order to begin incorporating Selenium, similar to how the page-object gem works. It's still very uncertain to me whether it makes sense to include Selenium at all so this will be a trial of that. Currently my focus is still on Watir and there is a lot of logic that does not yet work with Selenium.
+
+
 Version 0.1.7 / 2012-10-16
 --------------------------
 

data/lib/symbiont.rb

@@ -15,10 +15,8 @@ module Symbiont
   include Locators
   include DataSetter
   
-  # Used to make a platform object accessible. Will hold object
-  # references like these:
-  # <Symbiont::Platforms::WatirWebDriver::PlatformObject:0x2cbe8a0>
   attr_reader :platform
+  attr_reader :browser
 
   def self.version
     "Symbiont v#{Symbiont::VERSION}"
@@ -41,6 +39,12 @@ module Symbiont
     @page_wait ||= 15
   end
 
+  # Returns the default wait value for elements on a page. This value is
+  # the default value beyond which a timeout is assumed.
+  def self.element_level_wait
+    @element_wait ||= 5
+  end
+
   # The initialize method will be invoked when a page definition includes
   # Symbiont. Some key things are happening here that are critical to
   # Symbiont working correctly:
@@ -65,7 +69,7 @@ module Symbiont
   #
   # @param [Object] browser a browser instance with a tool driver
   def establish_platform_object_for(browser)
-    @platform = get_platform_for(browser)
+    @platform = get_platform_for(browser, Symbiont::Platforms.list)
   end
 
 end

data/lib/symbiont/enclosers.rb

@@ -52,7 +52,7 @@ module Symbiont
     #     @page.title.should == "Test App"
     #   end
     def wait_for(timeout=Symbiont.page_level_wait, message=nil, &block)
-      @platform.wait_for(timeout, message, &block)
+      platform.wait_for(timeout, message, &block)
     end
     
     # Provides a context for an action that will generate a JavaScript alert
@@ -66,7 +66,7 @@ module Symbiont
     #     @page.submitForm
     #   end
     def will_alert(&block)
-      @platform.will_alert(&block)
+      platform.will_alert(&block)
     end
     
     # Provides a context for an action that will generate a JavaScript
@@ -82,7 +82,7 @@ module Symbiont
     #     @page.areYouSure
     #   end
     def will_confirm(response, &block)
-      @platform.will_confirm(response, &block)
+      platform.will_confirm(response, &block)
     end
     
     # Provides a context for an action that will generate a JavaScript prompt
@@ -98,7 +98,7 @@ module Symbiont
     #     @page.useValue
     #   end
     def will_prompt(response, &block)
-      @platform.will_prompt(response, &block)
+      platform.will_prompt(response, &block)
     end
     
   end # module: Enclosers

data/lib/symbiont/evaluators.rb

@@ -1,71 +1,64 @@
 module Symbiont
   module Evaluators
     
-    # Visits a page via a specified URL. The URL can be specified as a domain
-    # address or as a file-based link.
-    # @param [String] url the full URL to navigate to
     def visit(url)
-      @platform.visit(url)
+      platform.visit(url)
     end
     
-    # Returns the text of the current page. This is the text minus any
-    # markup.
     def text
-      @platform.text
+      platform.text
     end
     
-    # Returns the markup of the current page.
     def markup
-      @platform.markup
+      platform.markup
     end
     
-    alias :html :markup
+    alias_method :html, :markup
     
-    # Returns the title of the current page.
     def title
-      @platform.title
+      platform.title
     end
     
-    # Returns the URL of the active page.
     def url
-      @platform.url
+      platform.url
     end
     
     # Save a snapshot of the current screen to a provided file location.
     # The file will be saved as a PNG file in the path specified or in the
     # location where the tests are being run from.
-    # @param [String] file the file name to save the image as
     def screenshot(file)
-      @platform.screenshot file
+      platform.screenshot file
     end    
     
-    # Returns the web object that currently has focus.
     def focus
-      @platform.focus
+      platform.focus
     end
-    
+
+    alias_method :what_has_focus?, :focus
+
     # Executes JavaScript against the browser instance.
     def run_script(script)
-      @platform.run_script(script)
+      platform.run_script(script)
     end
     
-    alias :execute_script :run_script
-    
+    alias_method :execute_script, :run_script
+
+    def back
+      platform.back
+    end
+
     # Provides an evaluator that attempts to wait for any pending AJAX
     # requests from the jQuery library.
-    #
-    # @param [Numeric] timeout amount of time to wait
-    # @param [String] message text to print if timeout period is exceeded
-    def wait_for_pending_requests(timeout=30, message=nil)
-      end_time = ::Time.now + timeout
+    def wait_for_pending_requests(time_limit=30, message_if_timeout=nil)
+      end_time = ::Time.now + time_limit
       until ::Time.now > end_time
         begin
-          return if @browser.execute_script('return jQuery.active') == 0
+          return if browser.execute_script('return jQuery.active') == 0
         rescue ReferenceError
         end
         sleep 0.5
       end
-      message = "Pending requests never indicated completion" unless message
+      message = "Pending jQuery requests never indicated completion." unless message_if_timeout
       raise message
     end
     

data/lib/symbiont/generators.rb

@@ -1,65 +1,28 @@
 module Symbiont
-
-  # The Generators module is used to provide groupings of methods that are
-  # generated dynamically based on object declarations in page definitions.
-  # The method provided allow for referencing and accessing web objects.
-  # The platform object acts as a delegate for all method calls.
-  
   module Generators
 
-    # This method allows for a url_is() method in definitions that will
-    # define a direct means of accessing a resource. The most common
-    # example will be a URL for a web page, but any URI is valid. The
-    # URL provided can be navigated to using the generated view() method
-    # on a definition instance.
-    #
-    # @param [String] url the resource identifier to access
-    # @return [Nil]
     def url_is(url)
       define_method("view") do
-        @platform.visit(url)
+        platform.visit(url)
       end
     end
 
-    # This method allows for a begin_at() method in definitions. The
-    # URL provided can be navigated to using the generated start()
-    # method on a definition instance.
-    #
-    # @see Symbiont::Generators#url_is
-    # @param [String] url the resource identifier to access
-    # @return [Nil]
     def begin_at(url)
       define_method("start") do
-        @platform.visit(url)
+        platform.visit(url)
       end
     end
 
-    # This method allows for a title_is() method in definitions. The idea
-    # is that you can specify the title of a page. This title can then be
-    # checked on. Note that the assumption here is that the title will
-    # be static. The argument to the method can, however, be a
-    # regular expression.
-    #
-    # @param [String] title the literal string of the expected title
-    # @param [Regexp] title the pattern string of the expected title
-    # @return [Nil]
-    # @raise exception if the title found does not match the title expected
     def title_is(title)
       define_method('has_title?') do
-        valid_title = title =~ @browser.title if title.kind_of?(Regexp)
-        valid_title = title == @browser.title if title.kind_of?(String)
-        raise "Expected title: '#{title}'; Actual title: '#{@browser.title}'" unless valid_title
+        sleep 1
+        valid_title = title =~ browser.title if title.kind_of?(Regexp)
+        valid_title = title == browser.title if title.kind_of?(String)
+        raise "\n\nExpected title: '#{title}'; Actual title: '#{browser.title}'" unless valid_title
         valid_title
       end
     end
     
-    # This method allows for a look_for() method in definitions. The idea
-    # is that you can specify an object that should appear on a given page
-    # when that page appears.
-    #
-    # @param [Symbol] widget the friendly name of the object declaration
-    # @param [optional, Integer] timeout the time to wait for the object to appear
-    # @return [Boolean] true if object was found
     def look_for(widget, timeout=5)
       define_method('has_object?') do
         if self.respond_to? "#{widget}_object"
@@ -69,283 +32,111 @@ module Symbiont
         end
       end
     end
-    
-    # Definition method for links. Methods for the following actions will
-    # be created:
-    # * reference a link (identifier_object, identifier_link)
-    # * check text of link (identifier_text)
-    # * click a link (identifier)
-    # * check for existence (identifier?, identifier_exists?)
-    # * check for visibility (identifier_?, identifier_visible?)
-    # @param [Symbol] identifier the friendly name of the web object
-    # @param [optional, Hash] locator the key/values that identify the object
-    # @return [Object] instance of Symbiont::WebObjects::Link
-    def link(identifier, locator)
-      define_method("#{identifier}_object") do
-        @platform.get_link_for(locator.clone)
-      end
 
-      alias_method "#{identifier}_link".to_sym, "#{identifier}_object".to_sym
-      
-      define_method("#{identifier}_text") do
-        @platform.get_link_text_for(locator.clone)
-      end
-      
+    def paragraph(identifier, locator)
       define_method(identifier) do
-        @platform.click_link_for(locator.clone)
+        platform.paragraph_text_for(locator.clone)
       end
 
-      define_method("#{identifier}_exists?") do
-        @platform.check_link_for_existence(locator.clone)
-      end
-      
-      alias_method "#{identifier}?".to_sym, "#{identifier}_exists?".to_sym
-      
-      define_method("#{identifier}_visible?") do
-        @platform.check_link_for_visibility(locator.clone)
-      end
-      
-      alias_method "#{identifier}_?".to_sym, "#{identifier}_visible?".to_sym
+      common_definition_methods(identifier, locator, 'paragraph_element')
     end
 
-    # Definition method for buttons. Methods for the following actions will
-    # be created:
-    # * reference a button (identifier_object, identifier_button)
-    # * get text from button (identifier_text)
-    # * click a button (identifier)
-    # * check for existence (identifier?, identifier_exists?)
-    # * check for visibility (identifier_?, identifier_visible?)
-    # * check for enabled (identifier!, identifier_enabled?)
-    # @param [Symbol] identifier the friendly name of the web object
-    # @param [optional, Hash] locator the key/values that identify the object
-    # @return [Object] instance of Symbiont::WebObjects::Button
-    def button(identifier, locator)
-      define_method("#{identifier}_object") do
-        @platform.get_button_for(locator.clone)
-      end
+    alias_method :p, :paragraph
 
-      alias_method "#{identifier}_button".to_sym, "#{identifier}_object".to_sym
-      
-      define_method("#{identifier}_text") do
-        @platform.get_button_text_for(locator.clone)
-      end
-      
+    def link(identifier, locator)
       define_method(identifier) do
-        @platform.click_button_for(locator.clone)
+        platform.click_link_for(locator.clone)
       end
 
-      define_method("#{identifier}_exists?") do
-        @platform.check_button_for_existence(locator.clone)
-      end
-      
-      alias_method "#{identifier}?".to_sym, "#{identifier}_exists?".to_sym
-      
-      define_method("#{identifier}_visible?") do
-        @platform.check_button_for_visibility(locator.clone)
-      end
-      
-      alias_method "#{identifier}_?".to_sym, "#{identifier}_visible?".to_sym
-      
-      define_method("#{identifier}_enabled?") do
-        @platform.check_button_for_enabled(locator.clone)
-      end
-      
-      alias_method "#{identifier}!".to_sym, "#{identifier}_enabled?".to_sym
+      common_definition_methods(identifier, locator, 'link_element')
     end
 
-    # Definition method for text fields. Methods for the following actions
-    # will be created:
-    # * reference a text field (identifier_object, identifier_text_field)
-    # * get text from a text field (identifier)
-    # * set text in a text field (identifier=)
-    # * check for existence (identifier?, identifier_exists?)
-    # * check for visibility (identifier_?, identifier_visible?)
-    # * check for enabled (identifier!, identifier_enabled?)
-    # @param [Symbol] identifier the friendly name of the web object
-    # @param [optional, Hash] locator the key/values that identify the object
-    # @return [Object] instance of Symbiont::WebObjects::TextField
-    def text_field(identifier, locator)
-      define_method("#{identifier}_object") do
-        @platform.get_text_field_for(locator.clone)
+    alias_method :a, :link
+
+    def button(identifier, locator)
+      define_method(identifier) do
+        platform.click_button_for(locator.clone)
       end
 
-      alias_method "#{identifier}_text_field".to_sym, "#{identifier}_object".to_sym
+      common_definition_methods(identifier, locator, 'button_element')
+    end
 
+    def text_field(identifier, locator)
       define_method(identifier) do
-        @platform.get_text_field_value_for(locator.clone)
+        platform.get_text_field_value_for(locator.clone)
       end
-      
+
       define_method("#{identifier}=") do |value|
-        @platform.set_text_field_value_for(locator.clone, value)
-      end
-      
-      define_method("#{identifier}_exists?") do
-        @platform.check_text_field_for_existence(locator.clone)
-      end
-      
-      alias_method "#{identifier}?".to_sym, "#{identifier}_exists?".to_sym
-      
-      define_method("#{identifier}_visible?") do
-        @platform.check_text_field_for_visibility(locator.clone)
+        platform.set_text_field_value_for(locator.clone, value)
       end
-      
-      alias_method "#{identifier}_?".to_sym, "#{identifier}_visible?".to_sym
-      
-      define_method("#{identifier}_enabled?") do
-        @platform.check_text_field_for_enabled(locator.clone)
-      end
-      
-      alias_method "#{identifier}!".to_sym, "#{identifier}_enabled?".to_sym
+
+      common_definition_methods(identifier, locator, 'text_field_element')
     end
     
-    # Definition method for select lists. Methods for the following actions
-    # will be created:
-    # * reference a checkbox (identifier_object, identifier_select_list)
-    # * check for existence (identifier?, identifier_exists?)
-    # * check for visibility (identifier_?, identifier_visible?)
-    # * check for enabled (identifier!, identifier_enabled?)
-    # * check for option (identifier_option?)
-    # * set selected value (identifier=)
-    # @param [Symbol] identifier the friendly name of the web object
-    # @param [optional, Hash] locator the key/values that identify the object
-    # @return [Object] instance of Symbiont::WebObjects::SelectList
     def select_list(identifier, locator)
-      define_method("#{identifier}_object") do
-        @platform.get_select_list_for(locator.clone)
-      end
-      
-      alias_method "#{identifier}_select_list".to_sym, "#{identifier}_object".to_sym
-      
       define_method(identifier) do
-        @platform.get_select_list_item_for(locator.clone)
+        platform.get_select_list_item_for(locator.clone)
       end
       
       define_method("#{identifier}_option?") do
-        @platform.get_select_list_value_for(locator.clone)
-      end
-      
-      define_method("#{identifier}=") do |value|
-        @platform.set_select_list_value_for(locator.clone, value)
-      end
-      
-      define_method("#{identifier}_exists?") do
-        @platform.check_select_list_for_existence(locator.clone)
+        platform.get_select_list_value_for(locator.clone)
       end
-      
-      alias_method "#{identifier}?".to_sym, "#{identifier}_exists?".to_sym
-      
-      define_method("#{identifier}_visible?") do
-        @platform.check_select_list_for_visibility(locator.clone)
+
+      define_method("#{identifier}_options?") do
+        object = self.send("#{identifier}_object")
+        (object && object.options) ? object.options.collect(&:text) : []
       end
-      
-      alias_method "#{identifier}_?".to_sym, "#{identifier}_visible?".to_sym
-      
-      define_method("#{identifier}_enabled?") do
-        @platform.check_select_list_for_enabled(locator.clone)
+
+      define_method("#{identifier}=") do |value|
+        platform.set_select_list_value_for(locator.clone, value)
       end
-      
-      alias_method "#{identifier}!".to_sym, "#{identifier}_enabled?".to_sym
+
+      common_definition_methods(identifier, locator, 'select_list_element')
     end
+
+    alias_method :select, :select_list
     
-    # Definition method for checkboxes. Methods for the following actions
-    # will be created:
-    # * reference a checkbox (identifier_object, identifier_checkbox)
-    # * check for existence (identifier?, identifier_exists?)
-    # * check for visibility (identifier_?, identifier_visible?)
-    # * check for enabled (identifier!, identifier_enabled?)
-    # * check for checked (identifier_checked?)
-    # * set checked state (check_identifier)
-    # * set unchecked state (uncheck_identifier)
-    # @param [Symbol] identifier the friendly name of the web object
-    # @param [optional, Hash] locator the key/values that identify the object
-    # @return [Object] instance of Symbiont::WebObjects::CheckBox
     def checkbox(identifier, locator)
-      define_method("#{identifier}_object") do
-        @platform.get_checkbox_for(locator.clone)
-      end
-      
-      alias_method "#{identifier}_checkbox".to_sym, "#{identifier}_object".to_sym
-      
       define_method("check_#{identifier}") do
-        @platform.check_checkbox_for(locator.clone)
+        platform.check_checkbox_for(locator.clone)
       end
       
       define_method("uncheck_#{identifier}") do
-        @platform.uncheck_checkbox_for(locator.clone)
+        platform.uncheck_checkbox_for(locator.clone)
       end
       
       define_method("#{identifier}_checked?") do
-        @platform.check_checkbox_for_checked(locator.clone)
-      end
-      
-      define_method("#{identifier}_exists?") do
-        @platform.check_checkbox_for_existence(locator.clone)
+        platform.check_checkbox_for_checked(locator.clone)
       end
-      
-      alias_method "#{identifier}?".to_sym, "#{identifier}_exists?".to_sym
-      
-      define_method("#{identifier}_visible?") do
-        @platform.check_checkbox_for_visibility(locator.clone)
-      end
-      
-      alias_method "#{identifier}_?".to_sym, "#{identifier}_visible?".to_sym
-      
-      define_method("#{identifier}_enabled?") do
-        @platform.check_checkbox_for_enabled(locator.clone)
-      end
-      
-      alias_method "#{identifier}!".to_sym, "#{identifier}_enabled?".to_sym
+
+      common_definition_methods(identifier, locator, 'checkbox_element')
     end
     
-    # Definition method for radios. Methods for the following actions will be created:
-    # * reference a radio (identifier_object, identifier_radio, identifier_radio_button)
-    # * check for existence (identifier?, identifier_exists?)
-    # * check for visibility (identifier_?, identifier_visible?)
-    # * check for enabled (identifier!, identifier_enabled?)
-    # * check for selected (identifier_set?, identifier_selected?)
-    # * set selected state (set_identifier, select_identifier)
-    # @param [Symbol] identifier the friendly name of the web object
-    # @param [optional, Hash] locator the key/values that identify the object
-    # @return [Object] instance of Symbiont::WebObjects::Radio
     def radio(identifier, locator)
-      define_method("#{identifier}_object") do
-        @platform.get_radio_for(locator.clone)
-      end
-      
-      alias_method "#{identifier}_radio".to_sym, "#{identifier}_object".to_sym
-      alias_method "#{identifier}_radio_button".to_sym, "#{identifier}_object".to_sym
+      #alias_method "#{identifier}_radio".to_sym, "#{identifier}_object".to_sym
+      #alias_method "#{identifier}_radio_button".to_sym, "#{identifier}_object".to_sym
       
       define_method("#{identifier}_selected?") do
-        @platform.check_radio_for_selected(locator.clone)
+        platform.check_radio_for_selected(locator.clone)
       end
       
       alias_method "#{identifier}_set?".to_sym, "#{identifier}_selected?".to_sym
       
       define_method("select_#{identifier}") do
-        @platform.select_radio_for(locator.clone)
+        platform.select_radio_for(locator.clone)
       end
       
       alias_method "set_#{identifier}".to_sym, "select_#{identifier}".to_sym
-      
-      define_method("#{identifier}_exists?") do
-        @platform.check_radio_for_existence(locator.clone)
-      end
-      
-      alias_method "#{identifier}?".to_sym, "#{identifier}_exists?".to_sym
-      
-      define_method("#{identifier}_visible?") do
-        @platform.check_radio_for_visibility(locator.clone)
-      end
-      
-      alias_method "#{identifier}_?".to_sym, "#{identifier}_visible?".to_sym
-      
-      define_method("#{identifier}_enabled?") do
-        @platform.check_radio_for_enabled(locator.clone)
-      end
-      
-      alias_method "#{identifier}!".to_sym, "#{identifier}_enabled?".to_sym
+
+      common_definition_methods(identifier, locator, 'radio_element')
     end
-    
+
+    alias_method :radio_button, :radio
+
+
+
+
+
     # Definition method for tables. Methods for the following actions will be created:
     # * reference a table (identifier_object, identifier_table)
     # * check for existence (identifier?, identifier_exists?)
@@ -405,68 +196,42 @@ module Symbiont
       end
     end
     
-    # Definition method for div objects. Methods for the following actions will be created:
-    # * reference a div (identifier_object, identifier_div)
-    # * check for existence (identifier?, identifier_exists?)
-    # * check for visibility (identifier_?, identifier_visible?)
-    # * get text from div (identifier)
-    # @param [Symbol] identifier the friendly name of the web object
-    # @param [optional, Hash] locator the key/values that identify the object
-    # @return [Object] instance of Symbiont::WebObjects::Div
     def div(identifier, locator)
-      define_method("#{identifier}_object") do
-        @platform.get_div_for(locator.clone)
-      end
-      
-      alias_method "#{identifier}_div".to_sym, "#{identifier}_object".to_sym
-      
-      define_method("#{identifier}_exists?") do
-        @platform.check_div_for_existence(locator.clone)
-      end
-      
-      alias_method "#{identifier}?".to_sym, "#{identifier}_exists?".to_sym
-      
-      define_method("#{identifier}_visible?") do
-        @platform.check_div_for_visibility(locator.clone)
-      end
-      
-      alias_method "#{identifier}_?".to_sym, "#{identifier}_visible?".to_sym
-      
-      define_method("#{identifier}") do
-        @platform.get_div_text_for(locator.clone)
-      end
+      common_definition_methods(identifier, locator, 'div_element')
     end
     
-    # Definition method for span objects. Methods for the following actions will be created:
-    # * reference a span (identifier_object, identifier_span)
-    # * check for existence (identifier?, identifier_exists?)
-    # * check for visibility (identifier_?, identifier_visible?)
-    # * get text from span (identifier)
-    # @param [Symbol] identifier the friendly name of the web object
-    # @param [optional, Hash] locator the key/values that identify the object
-    # @return [Object] instance of Symbiont::WebObjects::Span
     def span(identifier, locator)
+      common_definition_methods(identifier, locator, 'span_element')
+    end
+
+    def common_definition_methods(identifier, locator, method)
       define_method("#{identifier}_object") do
-        @platform.get_span_for(locator.clone)
+        platform.send(method, locator.clone)
       end
-      
-      alias_method "#{identifier}_span".to_sym, "#{identifier}_object".to_sym
-      
+
       define_method("#{identifier}_exists?") do
-        @platform.check_span_for_existence(locator.clone)
+        platform.send(method, locator.clone).exists?
       end
-      
-      alias_method "#{identifier}?".to_sym, "#{identifier}_exists?".to_sym
-      
+
       define_method("#{identifier}_visible?") do
-        @platform.check_span_for_visibility(locator.clone)
+        platform.send(method, locator.clone).visible?
       end
-      
-      alias_method "#{identifier}_?".to_sym, "#{identifier}_visible?".to_sym
-      
-      define_method("#{identifier}") do
-        @platform.get_span_text_for(locator.clone)
+
+      define_method("#{identifier}_enabled?") do
+        platform.send(method, locator.clone).enabled?
+      end
+
+      define_method("#{identifier}_text") do
+        platform.send(method, locator.clone).text
       end
+
+      element = method[0..method.index("_") - 1]
+
+      alias_method "#{identifier}_#{element}".to_sym, "#{identifier}_object".to_sym
+      alias_method "#{identifier}?".to_sym, "#{identifier}_exists?".to_sym
+      alias_method "#{identifier}_?".to_sym, "#{identifier}_visible?".to_sym
+      alias_method "#{identifier}!".to_sym, "#{identifier}_enabled?".to_sym
     end
+
   end # module: Generators
 end # module: Symbiont