symbiont 0.11.0 → 0.12.0

data/lib/symbiont/elements.rb

@@ -1,185 +1,186 @@
-module Symbiont
-  # Calls the Watir module to get a list of the factory methods that
-  # Watir uses to reference and access web objects.
-  #
-  # @return [Array] factory method list
-  def self.elements
-    unless @elements
-      @elements = Watir::Container.instance_methods
-      #@elements.delete(:extract_selector)
-    end
-    @elements
-  end
-
-  def self.settable
-    @settable ||= [:text_field, :file_field, :textarea]
-  end
-
-  def self.selectable
-    @selectable ||= [:select_list]
-  end
-
-  def self.settable?(element)
-    settable.include? element.to_sym
-  end
-
-  def self.selectable?(element)
-    selectable.include? element.to_sym
-  end
-
-  module Element
-    # Iterates through Watir factory methods. Each method is defined
-    # as a method that can be called on a page class. This is what
-    # allows element definitions to be created.
-    Symbiont.elements.each do |element|
-      define_method element do |*signature, &block|
-        identifier, locator = parse_signature(signature)
-        context = context_from_signature(locator, &block)
-        define_element_accessor(identifier, locator, element, &context)
-        define_set_accessor(identifier, locator, element, &context) if Symbiont.settable?(element)
-        define_select_accessor(identifier, locator, element, &context) if Symbiont.selectable?(element)
-      end
-    end
-
-    private
-
-    # Defines an accessor method for an element that allows the friendly
-    # name of the element to be proxied to a Watir element object that
-    # corresponds to the element type.
-    #
-    # @param identifier [Symbol] friendly name of element definition
-    # @param locator [Hash] locators for referencing the element
-    # @param element [Symbol] name of Watir-based object
-    # @param block [Proc] a context block
-    #
-    # @example
-    # This element definition:
-    #   text_field :weight, id: 'wt', index: 0
-    #
-    # passed in like this:
-    #   :weight, {:id => 'wt', :index => 0}, :text_field
-    #
-    # This allows access like this:
-    #   @page.weight.set '200'
-    #
-    # Access could also be done this way:
-    #   @page.weight(id: 'wt').set '200'
-    #
-    # The second approach would lead to the *values variable having
-    # an array like this: [{:id => 'wt'}].
-    #
-    # A third approach would be to utilize one element definition
-    # within the context of another. Consider the following element
-    # definitions:
-    #   article :practice, id: 'practice'
-    #
-    #   a :page_link do |text|
-    #     practice.a(text: text)
-    #   end
-    #
-    # These could be utilized as such:
-    #   on_view(Practice).page_link('Click Me').click
-    #
-    # This approach would lead to the *values variable having
-    # an array like this: ["Click Me"].
-    def define_element_accessor(identifier, locator, element, &block)
-      define_method "#{identifier}".to_sym do |*values|
-        if block_given?
-          instance_exec(*values, &block)
-        else
-          reference_element(element, locator)
-        end
-      end
-    end
-
-    # Defines an accessor method for an element that allows the value of
-    # the element to be set via appending an "=" to the friendly name
-    # (identifier) of the element passed in.
-    #
-    # @param identifier [Symbol] friendly name of element definition
-    # @param locator [Hash] locators for referencing the element
-    # @param element [Symbol] name of Watir-based object
-    # @param block [Proc] a context block
-    #
-    # @example
-    # This element definition:
-    #   text_field :weight, id: 'wt'
-    #
-    # Can be accessed in two ways:
-    #    @page.weight.set '200'
-    #    @page.weight = '200'
-    #
-    # The second approach would lead to the *values variable having
-    # an array like this: ['200']. The first approach would be
-    # handled by define_element_accessor instead.
-    def define_set_accessor(identifier, locator, element, &block)
-      define_method "#{identifier}=".to_sym do |*values|
-        accessor = if block_given?
-          instance_exec(&block)
-        else
-          reference_element(element, locator)
-        end
-
-        if accessor.respond_to?(:set)
-          accessor.set *values
-        else
-          accessor.send_keys *values
-        end
-      end
-    end
-
-    # Defines an accessor method for an element that allows the value of
-    # the element to be selected via appending an "=" to the friendly
-    # name (identifier) of the element passed in.
-    #
-    # @param identifier [Symbol] friendly name of element definition
-    # @param locator [Hash] locators for referencing the element
-    # @param element [Symbol] name of Watir-based object
-    # @param block [Proc] a context block
-    #
-    # @example
-    # This element definition:
-    #   select_list :city, id: 'city'
-    #
-    # Can be accessed in two ways:
-    #    @page.city.select 'Chicago'
-    #    @page.city = 'Chicago'
-    #
-    # The second approach would lead to the *values variable having
-    # an array like this: ['City']. The first approach would be
-    # handled by define_element_accessor instead.
-    def define_select_accessor(identifier, locator, element, &block)
-      define_method "#{identifier}=".to_sym do |*values|
-        if block_given?
-          instance_exec(&block).select *values
-        else
-          reference_element(element, locator).select *values
-        end
-      end
-    end
-
-    # Returns the identifier and locator portions of an element definition.
-    #
-    # @param signature [Array] full element definition
-    # @return [String] identifier and locator portions
-    def parse_signature(signature)
-      return signature.shift, signature.shift
-    end
-
-    # Returns the block or proc that serves as a context for an element
-    # definition.
-    #
-    # @param locator [Array] locators from element definition
-    # @param block [Proc] a context block
-    # @return [Proc] the context block or nil if there is no procedure
-    def context_from_signature(*locator, &block)
-      if block_given?
-        block
-      else
-        context = locator.shift
-        context.is_a?(Proc) && locator.empty? ? context : nil
-      end
-    end
-
-  end
-end
+module Symbiont
+  # Calls the Watir module to get a list of the factory methods that
+  # Watir uses to reference and access web objects.
+  #
+  # @return [Array] factory method list
+  def self.elements
+    unless @elements
+      @elements = Watir::Container.instance_methods
+      # @elements.delete(:extract_selector)
+    end
+    @elements
+  end
+
+  def self.settable
+    @settable ||= [:text_field, :file_field, :textarea]
+  end
+
+  def self.selectable
+    @selectable ||= [:select_list]
+  end
+
+  def self.settable?(element)
+    settable.include? element.to_sym
+  end
+
+  def self.selectable?(element)
+    selectable.include? element.to_sym
+  end
+
+  module Element
+    # Iterates through Watir factory methods. Each method is defined
+    # as a method that can be called on a page class. This is what
+    # allows element definitions to be created.
+    Symbiont.elements.each do |element|
+      define_method element do |*signature, &block|
+        identifier, locator = parse_signature(signature)
+        context = context_from_signature(locator, &block)
+        define_element_accessor(identifier, locator, element, &context)
+        define_set_accessor(identifier, locator, element, &context) if Symbiont.settable?(element)
+        define_select_accessor(identifier, locator, element, &context) if Symbiont.selectable?(element)
+      end
+    end
+
+    private
+
+    # Defines an accessor method for an element that allows the friendly
+    # name of the element to be proxied to a Watir element object that
+    # corresponds to the element type.
+    #
+    # @param identifier [Symbol] friendly name of element definition
+    # @param locator [Hash] locators for referencing the element
+    # @param element [Symbol] name of Watir-based object
+    # @param block [Proc] a context block
+    #
+    # @example
+    # This element definition:
+    #   text_field :weight, id: 'wt', index: 0
+    #
+    # passed in like this:
+    #   :weight, {:id => 'wt', :index => 0}, :text_field
+    #
+    # This allows access like this:
+    #   @page.weight.set '200'
+    #
+    # Access could also be done this way:
+    #   @page.weight(id: 'wt').set '200'
+    #
+    # The second approach would lead to the *values variable having
+    # an array like this: [{:id => 'wt'}].
+    #
+    # A third approach would be to utilize one element definition
+    # within the context of another. Consider the following element
+    # definitions:
+    #   article :practice, id: 'practice'
+    #
+    #   a :page_link do |text|
+    #     practice.a(text: text)
+    #   end
+    #
+    # These could be utilized as such:
+    #   on_view(Practice).page_link('Click Me').click
+    #
+    # This approach would lead to the *values variable having
+    # an array like this: ["Click Me"].
+    def define_element_accessor(identifier, locator, element, &block)
+      define_method "#{identifier}".to_sym do |*values|
+        if block_given?
+          instance_exec(*values, &block)
+        else
+          reference_element(element, locator)
+        end
+      end
+    end
+
+    # Defines an accessor method for an element that allows the value of
+    # the element to be set via appending an "=" to the friendly name
+    # (identifier) of the element passed in.
+    #
+    # @param identifier [Symbol] friendly name of element definition
+    # @param locator [Hash] locators for referencing the element
+    # @param element [Symbol] name of Watir-based object
+    # @param block [Proc] a context block
+    #
+    # @example
+    # This element definition:
+    #   text_field :weight, id: 'wt'
+    #
+    # Can be accessed in two ways:
+    #    @page.weight.set '200'
+    #    @page.weight = '200'
+    #
+    # The second approach would lead to the *values variable having
+    # an array like this: ['200']. The first approach would be
+    # handled by define_element_accessor instead.
+    def define_set_accessor(identifier, locator, element, &block)
+      define_method "#{identifier}=".to_sym do |*values|
+        accessor =
+        if block_given?
+          instance_exec(&block)
+        else
+          reference_element(element, locator)
+        end
+
+        if accessor.respond_to?(:set)
+          accessor.set(*values)
+        else
+          accessor.send_keys(*values)
+        end
+      end
+    end
+
+    # Defines an accessor method for an element that allows the value of
+    # the element to be selected via appending an "=" to the friendly
+    # name (identifier) of the element passed in.
+    #
+    # @param identifier [Symbol] friendly name of element definition
+    # @param locator [Hash] locators for referencing the element
+    # @param element [Symbol] name of Watir-based object
+    # @param block [Proc] a context block
+    #
+    # @example
+    # This element definition:
+    #   select_list :city, id: 'city'
+    #
+    # Can be accessed in two ways:
+    #    @page.city.select 'Chicago'
+    #    @page.city = 'Chicago'
+    #
+    # The second approach would lead to the *values variable having
+    # an array like this: ['City']. The first approach would be
+    # handled by define_element_accessor instead.
+    def define_select_accessor(identifier, locator, element, &block)
+      define_method "#{identifier}=".to_sym do |*values|
+        if block_given?
+          instance_exec(&block).select(*values)
+        else
+          reference_element(element, locator).select(*values)
+        end
+      end
+    end
+
+    # Returns the identifier and locator portions of an element definition.
+    #
+    # @param signature [Array] full element definition
+    # @return [String] identifier and locator portions
+    def parse_signature(signature)
+      # return signature.shift, signature.shift
+      [signature.shift, signature.shift]
+    end
+
+    # Returns the block or proc that serves as a context for an element
+    # definition.
+    #
+    # @param locator [Array] locators from element definition
+    # @param block [Proc] a context block
+    # @return [Proc] the context block or nil if there is no procedure
+    def context_from_signature(*locator, &block)
+      if block_given?
+        block
+      else
+        context = locator.shift
+        context.is_a?(Proc) && locator.empty? ? context : nil
+      end
+    end
+  end
+end

data/lib/symbiont/errors.rb

@@ -1,9 +1,9 @@
-module Symbiont
-  module Errors
-    class NoUrlForDefinition < StandardError; end
-    class NoUrlMatchForDefinition < StandardError; end
-    class NoTitleForDefinition < StandardError; end
-    class WorkflowPathNotFound < StandardError; end
-    class WorkflowActionNotFound < StandardError; end
-  end
-end
+module Symbiont
+  module Errors
+    class NoUrlForDefinition < StandardError; end
+    class NoUrlMatchForDefinition < StandardError; end
+    class NoTitleForDefinition < StandardError; end
+    class WorkflowPathNotFound < StandardError; end
+    class WorkflowActionNotFound < StandardError; end
+  end
+end

data/lib/symbiont/factory.rb

@@ -1,87 +1,75 @@
-module Symbiont
-  module Factory
-    include Workflow
-
-    # Creates a definition context for actions. If an existing context
-    # exists, that context will be re-used.
-    #
-    # @param definition [Class] the name of a definition class
-    # @param visit [Boolean] true if the context needs to be called into view
-    # @param block [Proc] logic to execute in the context of the definition
-    # @return [Object] instance of the definition
-    def on(definition, visit=false, &block)
-      if @page.kind_of?(definition)
-        block.call @page if block
-        return @page
-      end
-
-      if @context.kind_of?(definition)
-        block.call @context if block
-
-        unless @page.kind_of?(definition)
-          @page = @context
-        end
-
-        return @context
-      end
-
-      @page = definition.new(@browser)
-      @page.view if visit
-
-      @page.has_correct_url? if @page.respond_to?(:url_matches)
-      @page.has_correct_title? if @page.respond_to?(:title_is)
-
-      @model = @page
-
-      block.call @page if block
-
-      @page
-    end
-
-    alias_method :on_page, :on
-    alias_method :while_on, :on
-
-    # Creates a definition context for actions and establishes the
-    # context for display.
-    #
-    # @param definition [Class] the name of a definition class
-    # @param block [Proc] logic to execute in the context of the definition
-    # @return [Object] instance of the definition
-    def on_view(definition, &block)
-      on(definition, true, &block)
-    end
-
-    alias_method :on_visit, :on_view
-
-    # Creates a definition context for actions. Unlike the on() factory,
-    # on_new will always create a new context and will never re-use an
-    # existing one.
-    #
-    # @param definition [Class] the name of a definition class
-    # @param block [Proc] logic to execute in the context of the definition
-    # @return [Object] instance of the definition
-    def on_new(definition, &block)
-      @page = nil
-      @model = nil
-
-      if @context.kind_of?(definition)
-        @context = nil
-      end
-      
-      on(definition, &block)
-    end
-
-    # Creates a definition context for actions. If an existing context
-    # exists, that context will be re-used. This also sets a context that
-    # will be used for that definition even if the active definition
-    # changes.
-    #
-    # @param definition [Class] the name of a definition class
-    # @param block [Proc] logic to execute within the context of the definition
-    # @return [Object] instance of the definition
-    def on_set(definition, &block)
-      on(definition, &block)
-      @context = @page
-    end
-  end
-end
+module Symbiont
+  module Factory
+    # Creates a definition context for actions. If an existing context
+    # exists, that context will be re-used.
+    #
+    # @param definition [Class] the name of a definition class
+    # @param visit [Boolean] true if the context needs to be called into view
+    # @param block [Proc] logic to execute in the context of the definition
+    # @return [Object] instance of the definition
+    def on(definition, visit = false, &block)
+      if @page.is_a?(definition)
+        block.call @page if block
+        return @page
+      end
+
+      if @context.is_a?(definition)
+        block.call @context if block
+        @page = @context
+        return @context
+      end
+
+      @page = definition.new(@browser)
+      @page.view if visit
+
+      @model = @page
+
+      block.call @page if block
+
+      @page
+    end
+
+    alias_method :on_page, :on
+    alias_method :while_on, :on
+
+    # Creates a definition context for actions and establishes the
+    # context for display.
+    #
+    # @param definition [Class] the name of a definition class
+    # @param block [Proc] logic to execute in the context of the definition
+    # @return [Object] instance of the definition
+    def on_view(definition, &block)
+      on(definition, true, &block)
+    end
+
+    alias_method :on_visit, :on_view
+
+    # Creates a definition context for actions. Unlike the on() factory,
+    # on_new will always create a new context and will never re-use an
+    # existing one.
+    #
+    # @param definition [Class] the name of a definition class
+    # @param block [Proc] logic to execute in the context of the definition
+    # @return [Object] instance of the definition
+    def on_new(definition, &block)
+      @page = nil
+      @model = nil
+
+      @context = nil if @context.is_a?(definition)
+      on(definition, &block)
+    end
+
+    # Creates a definition context for actions. If an existing context
+    # exists, that context will be re-used. This also sets a context that
+    # will be used for that definition even if the active definition
+    # changes.
+    #
+    # @param definition [Class] the name of a definition class
+    # @param block [Proc] logic to execute within the context of the definition
+    # @return [Object] instance of the definition
+    def on_set(definition, &block)
+      on(definition, &block)
+      @context = @page
+    end
+  end
+end

data/lib/symbiont/helpers.rb

@@ -1,50 +1,52 @@
-module Symbiont
-  module Helpers
-
-    private
-
-    def url_is_empty
-      puts "\nERROR".on_red
-      puts "The url_is assertion is empty on the definition #{retrieve_class(caller)}.".cyan
-      raise Symbiont::Errors::NoUrlForDefinition
-    end
-
-    def url_match_is_empty
-      puts "\nERROR".on_red
-      puts "The url_matches assertion is empty on the definition #{retrieve_class(caller)}.".cyan
-      raise Symbiont::Errors::NoUrlMatchForDefinition
-    end
-
-    def title_is_empty
-      puts "\nERROR".on_red
-      puts "The title_is assertion is empty on the definition #{retrieve_class(caller)}.".cyan
-      raise Symbiont::Errors::NoTitleForDefinition
-    end
-
-    def no_url_is_provided
-      puts "\nERROR".on_red
-      puts "You called a '#{retrieve_method(caller)}' action but the definition #{self.class} does not have a url_is assertion.".cyan
-      raise Symbiont::Errors::NoUrlForDefinition
-    end
-
-    def no_url_matches_is_provided
-      puts "\nERROR".on_red
-      puts "You called a '#{retrieve_method(caller)}' action but the definition #{self.class} does not have a url_matches assertion.".cyan
-      raise Symbiont::Errors::NoUrlMatchForDefinition
-    end
-
-    def no_title_is_provided
-      puts "\nERROR".on_red
-      puts "You called a '#{retrieve_method(caller)}' action but the definition #{self.class} does not have a title_is assertion.".cyan
-      raise Symbiont::Errors::NoTitleForDefinition
-    end
-
-    def retrieve_class(caller)
-      caller[1][/`.*'/][8..-3]
-    end
-
-    def retrieve_method(caller)
-      caller[0][/`.*'/][1..-2]
-    end
-  end
-end
+module Symbiont
+  module Helpers
+    private
+
+    def url_is_empty
+      puts "\nERROR".on_red
+      puts "The url_is assertion is empty on the definition #{retrieve_class(caller)}.".cyan
+      raise Symbiont::Errors::NoUrlForDefinition
+    end
+
+    def url_match_is_empty
+      puts "\nERROR".on_red
+      puts "The url_matches assertion is empty on the definition #{retrieve_class(caller)}.".cyan
+      raise Symbiont::Errors::NoUrlMatchForDefinition
+    end
+
+    def title_is_empty
+      puts "\nERROR".on_red
+      puts "The title_is assertion is empty on the definition #{retrieve_class(caller)}.".cyan
+      raise Symbiont::Errors::NoTitleForDefinition
+    end
+
+    def no_url_is_provided
+      puts "\nERROR".on_red
+      puts "You called a '#{retrieve_method(caller)}' action but the \
+        definition #{self.class} does not have a url_is assertion.".cyan
+      raise Symbiont::Errors::NoUrlForDefinition
+    end
+
+    def no_url_matches_is_provided
+      puts "\nERROR".on_red
+      puts "You called a '#{retrieve_method(caller)}' action but the \
+        definition #{self.class} does not have a url_matches assertion.".cyan
+      raise Symbiont::Errors::NoUrlMatchForDefinition
+    end
+
+    def no_title_is_provided
+      puts "\nERROR".on_red
+      puts "You called a '#{retrieve_method(caller)}' action but the \
+        definition #{self.class} does not have a title_is assertion.".cyan
+      raise Symbiont::Errors::NoTitleForDefinition
+    end
+
+    def retrieve_class(caller)
+      caller[1][/`.*'/][8..-3]
+    end
+
+    def retrieve_method(caller)
+      caller[0][/`.*'/][1..-2]
+    end
+  end
+end