cornucopia 0.1.12

data/lib/cornucopia/cucumber_hooks.rb

@@ -0,0 +1,38 @@
+require ::File.expand_path("../cornucopia", File.dirname(__FILE__))
+require ::File.expand_path("../cornucopia/factory_girl/dynamic_association", File.dirname(__FILE__))
+
+load ::File.expand_path("capybara/install_finder_extensions.rb", File.dirname(__FILE__))
+load ::File.expand_path("capybara/install_matcher_extensions.rb", File.dirname(__FILE__))
+load ::File.expand_path("site_prism/install_element_extensions.rb", File.dirname(__FILE__))
+
+Around do |scenario, block|
+  seed_value = Cornucopia::Util::Configuration.seed ||
+      100000000000000000000000000000000000000 + rand(899999999999999999999999999999999999999)
+
+  scenario.instance_variable_set :@seed_value, seed_value
+
+  block.call
+
+  if scenario.failed?
+    seed_value = scenario.instance_variable_get(:@seed_value)
+    puts ("random seed for testing was: #{seed_value}")
+  end
+end
+
+After do |scenario|
+  if scenario.failed?
+    Cornucopia::Util::ReportBuilder.current_report.
+        within_section("Test Error: #{scenario.feature.title}:#{scenario.title}") do |report|
+      configured_report = Cornucopia::Util::Configuration.report_configuration :cucumber
+
+      configured_report.add_report_objects scenario: scenario, cucumber: self
+      configured_report.generate_report(report)
+    end
+  end
+end
+
+at_exit do
+  Cornucopia::Util::ReportBuilder.current_report.close
+end
+
+Cornucopia::Util::ReportBuilder.new_report("cucumber_report")

data/lib/cornucopia/factory_girl/dynamic_association.rb

@@ -0,0 +1,14 @@
+module Cornucopia
+  module FactoryGirl
+    class DynamicAssociations
+      ##
+      # association creates an association which allows arguments or will call a block to create the
+      # associated object.
+      #
+      #
+      def association(name, options, &block)
+        options
+      end
+    end
+  end
+end

data/lib/cornucopia/rspec_hooks.rb

@@ -0,0 +1,37 @@
+require ::File.expand_path("../cornucopia", File.dirname(__FILE__))
+load ::File.expand_path("capybara/install_finder_extensions.rb", File.dirname(__FILE__))
+load ::File.expand_path("capybara/install_matcher_extensions.rb", File.dirname(__FILE__))
+load ::File.expand_path("site_prism/install_element_extensions.rb", File.dirname(__FILE__))
+
+RSpec.configure do |config|
+  config.before(:suite) do |*args|
+    Cornucopia::Util::ReportBuilder.new_report("rspec_report")
+  end
+
+  config.after(:suite) do
+    Cornucopia::Util::ReportBuilder.current_report.close
+  end
+
+  config.around(:each) do |example|
+    @seed_value = Cornucopia::Util::Configuration.seed ||
+        100000000000000000000000000000000000000 + rand(899999999999999999999999999999999999999)
+
+    srand(@seed_value)
+
+    example.run
+
+    test_example = example.example if example.respond_to?(:example)
+    test_example ||= self.example if self.respond_to?(:example)
+    if (test_example.exception)
+      puts ("random seed for testing was: #{@seed_value}")
+
+      Cornucopia::Util::ReportBuilder.current_report.
+          within_section("Test Error: #{test_example.full_description}") do |report|
+        configured_report = Cornucopia::Util::Configuration.report_configuration :rspec
+
+        configured_report.add_report_objects example: test_example
+        configured_report.generate_report(report)
+      end
+    end
+  end
+end

data/lib/cornucopia/site_prism/element_extensions.rb

@@ -0,0 +1,273 @@
+require 'active_support/concern'
+
+module Cornucopia
+  module SitePrism
+    module ElementExtensions
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        # patterned_elements defines a set of elements where the find pattern is based on the
+        # name that will be used for the element.
+        #
+        # element will be called once for each element with the find pattern where the string
+        # `%{element_name}` will be replace with the name for the element.
+        # The pattern must include `%{element_name}`.
+        #
+        # Parameters:
+        #   pattern   - String - This is the pattern that will be used to create the find option
+        #               for the element.  The pattern must include `%{element_name}`.
+        #   elements  - An array of symbols for the elements which will be defined.
+        #   options   - A set of options
+        #               find_type:          The type of the finder which will be used.  The default is :css
+        #               element_array:      If not false or nil, this will cause the function to call `elements` instead
+        #                                   of `element`
+        #               additional_options: A hash of additional options which will be sent to element call.
+        #
+        # Examples:
+        #   patterned_elements "\#%{element_name}",
+        #                      :user_first_name,
+        #                      :user_last_name,
+        #                      :user_middle_name,
+        #                      :user_sex
+        #
+        #     Will call:
+        #       element :user_first_name, "\#user_first_name"
+        #       element :user_last_name, "\#user_last_name"
+        #       element :user_middle_name, "\#user_middle_name"
+        #       element :user_sex, "\#user_sex"
+        #
+        #   patterned_elements "//option[contains(text(), \"${element_name}\")]",
+        #                      :Cincinati,
+        #                      :Chicago,
+        #                      :Denver,
+        #                      find_type: :xpath,
+        #                      additional_options: { visible: false }
+        #
+        #     Will call:
+        #       element :Cincinati, :xpath, "//option[contains(text(), \"Cincinati\")]", visible: false
+        #       element :Chicago, :xpath, "//option[contains(text(), \"Chicago\")]", visible: false
+        #       element :Denver, :xpath, "//option[contains(text(), \"Denver\")]", visible: false
+        def patterned_elements(pattern, *elements)
+          options = elements.extract_options!
+
+          unless pattern =~ /\%\{element_name\}/
+            raise Exception.new("Invalid pattern \"#{pattern}\".  Pattern must contain \"%{element_name}\".")
+          end
+
+          element_function = :element
+          element_function = :elements if options[:element_array]
+
+          element_name_index = 0
+          options_array      = []
+          if options[:find_type]
+            options_array << options[:find_type]
+            element_name_index += 1
+          end
+          options_array << :__blank__
+          options_array << pattern
+          options_array << options[:additional_options] if options[:additional_options]
+
+          elements.each do |element_name|
+            options_array[element_name_index]     = element_name.to_s.gsub(/[-]/, "_").to_sym
+            options_array[element_name_index + 1] = pattern % { element_name: element_name }
+            send element_function, *options_array
+          end
+        end
+
+        # form_elements defines an ID finder for most form elements.  Given a <model_name> and an
+        # array of <field_name>s, this function will call `element` once for each <field_name>
+        # defining an id based element assuming it was definied within a form for <model_name>.
+        #
+        # This is based off the fact that the IDs for most form elements follows a basic pattern
+        # of:  "<model_name>_<field_name>".
+        #
+        # Parameters:
+        #   model_name
+        #   field_names
+        #   options   - A set of options
+        #               element_array:      If not false or nil, this will cause the function to call `elements` instead
+        #                                   of `element`
+        #
+        # Example:
+        #   form_elements :user,
+        #                 :first_name,
+        #                 :last_name,
+        #                 :middle_name,
+        #                 :sex
+        #
+        #     Will call:
+        #       element :first_name, "\#user_first_name"
+        #       element :last_name, "\#user_last_name"
+        #       element :middle_name, "\#user_middle_name"
+        #       element :sex, "\#user_sex"
+        def form_elements(model_name, *field_names)
+          options = field_names.extract_options!
+
+          patterned_elements "\##{model_name}_%{element_name}", *field_names, options.slice(:element_array)
+        end
+
+        # id_elements defines an ID finder where the id of the element is the name for the element.
+        #
+        # Parameters:
+        #   element_names - An array of elements to define where the id of the element is the same as the element name
+        #   options       - A set of options
+        #                   element_array:      If not false or nil, this will cause the function to call `elements` instead
+        #                                       of `element`
+        #
+        # Example:
+        #   id_elements :some_object,
+        #               :another_object
+        #
+        #     Will call:
+        #       element :some_object, "\#some_object"
+        #       element :another_object, "\#another_object"
+        def id_elements(*element_names)
+          options = element_names.extract_options!
+
+          patterned_elements "\#%{element_name}", *element_names, options.slice(:element_array)
+        end
+
+        # class_elements defines an ID finder where the class of the element is the name for the element.
+        #
+        # Parameters:
+        #   element_names - An array of elements to define where the id of the element is the same as the element name
+        #   options       - A set of options
+        #                   element_array:      If not false or nil, this will cause the function to call `elements` instead
+        #                                       of `element`
+        #
+        # Example:
+        #   id_elements :some_object,
+        #               :another_object
+        #
+        #     Will call:
+        #       element :some_object, ".some_object"
+        #       element :another_object, ".another_object"
+        def class_elements(*element_names)
+          options = element_names.extract_options!
+
+          patterned_elements ".%{element_name}", *element_names, options.slice(:element_array)
+        end
+
+        # indexed_elements defines a set of elements where the finder pattern can be based off of
+        # an index value.
+        #
+        # This can be useful for table columns for example.
+        #
+        # Parameters:
+        #   index_pattern   - String - This is the pattern that will be used to create the find option
+        #                     for the element.  The pattern must include `%{element_index}`.
+        #   element_names   - An array of symbols for the elements which will be defined.
+        #                     The name :__skip__ will be ignored.  Ignored elements will always increment by one and
+        #                     will ignore the increment value.
+        #   options         - A set of options
+        #                     find_type:          The type of the finder which will be used.  The default is :css
+        #                     element_array:      If not false or nil, this will cause the function to call `elements` instead
+        #                                         of `element`
+        #                     additional_options: A hash of additional options which will be sent to element call.
+        #                     start_index:        The start value for the first index element.
+        #                     increment:          The amount the index will be incremented by each time.
+        #
+        # Examples:
+        #   indexed_elements "\#my_table tr td:nth-child(%{element_index})",
+        #                      :first_name,
+        #                      :last_name,
+        #                      :middle_name,
+        #                      :sex
+        #
+        #     Will call:
+        #       element :first_name, "\#my_table tr td:nth-child(1)"
+        #       element :last_name, "\#my_table tr td:nth-child(2)"
+        #       element :middle_name, "\#my_table tr td:nth-child(3)"
+        #       element :sex, "\#my_table tr td:nth-child(4)"
+        #
+        #   indexed_elements "\#my_table tr td:nth-child(%{element_index})",
+        #                      :first_name,
+        #                      :last_name,
+        #                      :middle_name,
+        #                      :__skip__
+        #                      :sex
+        #
+        #     Will call:
+        #       element :first_name, "\#my_table tr td:nth-child(1)"
+        #       element :last_name, "\#my_table tr td:nth-child(2)"
+        #       element :middle_name, "\#my_table tr td:nth-child(3)"
+        #       element :sex, "\#my_table tr td:nth-child(5)"
+        #
+        #   indexed_elements "\#my_table tr td:nth-child(%{element_index})",
+        #                      :first_name,
+        #                      :last_name,
+        #                      :middle_name,
+        #                      :__skip__
+        #                      :sex,
+        #                      start_index: 4
+        #                      increment:   3
+        #
+        #     Will call:
+        #       element :first_name, "\#my_table tr td:nth-child(4)"
+        #       element :last_name, "\#my_table tr td:nth-child(7)"
+        #       element :middle_name, "\#my_table tr td:nth-child(10)"
+        #       element :sex, "\#my_table tr td:nth-child(12)"
+        def indexed_elements(index_pattern, *element_names)
+          options = element_names.extract_options!
+
+          element_function = :element
+          element_function = :elements if options[:element_array]
+
+          element_index   = options[:start_index] || 1
+          index_increment = options[:increment] || 1
+
+          unless index_pattern =~ /\%\{element_index\}/
+            raise Exception.new("Invalid index_pattern \"#{index_pattern}\".  Pattern must contain \"%{element_index}\".")
+          end
+          raise Exception.new("Increment value may not be 0") if index_increment == 0
+
+          options_array      = []
+          element_name_index = 0
+          if options[:find_type]
+            options_array << options[:find_type]
+            element_name_index += 1
+          end
+          options_array << :__blank__
+          options_array << index_pattern
+          options_array << options[:additional_options] if options[:additional_options]
+
+          element_names.each do |element_name|
+            if [:__blank__, :__skip__].include?(element_name)
+              element_index += 1
+              next
+            end
+
+            options_array[element_name_index]     = element_name
+            options_array[element_name_index + 1] = index_pattern % { element_index: element_index }
+            send element_function, *options_array
+            element_index += index_increment
+          end
+        end
+
+        # I don't need this right now.
+        # I am thinking that I should try using x-path next time I need this.
+        #
+        # # immediate_child_element element_name, find_string == element element_name, "> #{find_string}"
+        # def immediate_child_element(element_name, *find_args)
+        #   self.class_eval do
+        #     elements "__cornucopia_element_#{element_name}", *find_args
+        #   end
+        #
+        #   define_method element_name.to_s do
+        #     the_element = send("__cornucopia_element_#{element_name}").reduce([]) do |array, element|
+        #       array << element if element.parent == self.root_element
+        #       array
+        #     end
+        #
+        #     raise ::Capybara::ElementNotFound unless the_element.length > 0
+        #     raise ::Capybara::Ambiguous unless the_element.length == 1
+        #
+        #     the_element[0]
+        #   end
+        # end
+      end
+    end
+  end
+end
+
+load ::File.expand_path("install_element_extensions.rb", File.dirname(__FILE__))

data/lib/cornucopia/site_prism/install_element_extensions.rb

@@ -0,0 +1,23 @@
+$cornucopia_element_extension_installed = false unless defined? $cornucopia_element_extension_installed
+
+if Object.const_defined?("SitePrism") &&
+    ::SitePrism.const_defined?("Page") &&
+    !$cornucopia_element_extension_installed
+  module ::SitePrism
+    class Page
+      include Cornucopia::SitePrism::ElementExtensions
+    end
+  end
+end
+
+if Object.const_defined?("SitePrism") &&
+    ::SitePrism.const_defined?("Section") &&
+    !$cornucopia_element_extension_installed
+  $cornucopia_element_extension_installed = true
+
+  module ::SitePrism
+    class Section
+      include Cornucopia::SitePrism::ElementExtensions
+    end
+  end
+end

data/lib/cornucopia/site_prism/page_application.rb

@@ -0,0 +1,126 @@
+module Cornucopia
+  module SitePrism
+    # PageApplication is a class used to fetch page objects and memoize them
+    # without really having to know anything about them.
+    #
+    # This class is intended to be the base class for a page application object.
+    #
+    # An example of how it is designed to work is:
+    #
+    # class MyApplication < Cornucopia::SitePrism::PageApplication
+    #   def pages_module
+    #     MyPagesModule
+    #   end
+    # end
+    #
+    # module MyPagesModule
+    #   class MyPage < SitePrism::Page
+    #   end
+    # end
+    #
+    # page = MyApplication.my_page
+    #
+    #
+    # The system works as follows:
+    #   * Pages are defined as:  BaseModule::SubModule::NamePage
+    #       BaseModule:: is optional
+    #       SubModule:: is optional and you can have as many levels as you want
+    #       Name is the name of the page
+    #       Page is recommended to distinguish pages from sections
+    #
+    #   * A singleton instance of your application class is memoized.  That instance
+    #     is used to instantiate and memoize all of the page objects.  Additional
+    #     functions and properties which you may need may be added to this class.
+    #     Remember, this singleton instance is instantiated once per test run and
+    #     will be reused in multiple tests.
+    #
+    #   * To get a page object, simply use your class object and call the underscored name
+    #     of the page and its modules as a class method.  The class method name will be
+    #     deconstructed and constantized into a page object.  The page object will be created
+    #     once and then cached for future use.  Use 2 underscores (__) between modules.
+    #       To get the sample page it would be:  MyApplication.sub_module__name_page
+    #
+    # All you have to do is define the page objects under a single module namespace and the
+    # application class will recognize the pages and return them.
+
+    class PageApplication
+      @@current_instances = {}
+
+      def pages_module
+        Object
+      end
+
+      class << self
+        def current_instance
+          @@current_instances[self.name] ||= self.new
+        end
+
+        # Redirect any non-class methods to the instance if the instance supports them.
+        def method_missing(method_sym, *arguments, &block)
+          if self.current_instance.respond_to?(method_sym, true)
+            self.current_instance.send(method_sym, *arguments)
+          else
+            super
+          end
+        end
+
+        def respond_to?(method_sym, include_private = false)
+          if self.current_instance.respond_to?(method_sym, include_private)
+            true
+          else
+            super
+          end
+        end
+      end
+
+      def is_page_name?(method_name)
+        is_page_name = false
+        if method_name =~ /^[@a-z0-9_]+$/i
+          base_class = pages_module
+
+          is_page_name = true
+          method_name.split("__").each do |module_name|
+            if module_name.blank?
+              is_page_name = false
+              break;
+            end
+
+            unless base_class.const_defined?(module_name.camelize)
+              is_page_name = false
+              break
+            end
+
+            base_class = "#{base_class}::#{module_name.camelize}".constantize
+          end
+        end
+
+        is_page_name
+      end
+
+      def method_missing(method_sym, *arguments, &block)
+        method_name = method_sym.to_s
+        if is_page_name?(method_name)
+          return_page = instance_variable_get("@#{method_name}")
+          unless return_page
+            return_page = "#{pages_module.to_s}::#{method_name.split("__").map(&:camelize).join("::")}".constantize.new
+            instance_variable_set("@#{method_name}", return_page)
+          end
+
+          return_page
+        else
+          super
+        end
+      end
+
+      def respond_to?(method_sym, include_private = false)
+        method_name = method_sym.to_s
+
+        if is_page_name?(method_name)
+          true
+        else
+          super
+        end
+      end
+    end
+  end
+end