voluntary 0.0.1 → 0.0.2

data/lib/generators/voluntary/product_dummy/templates/config/main_navigation.rb

@@ -0,0 +1,262 @@
+SimpleNavigation::Configuration.run do |navigation|  
+  navigation.items do |primary|
+    primary.dom_class = 'nav'
+    primary.item :root, t('general.index.title'), root_path
+    
+    primary.item :areas, t('areas.index.title'), areas_path do |areas|
+      areas.item :new, t('general.new'), new_area_path
+      
+      unless (@area.new_record? rescue true)
+        areas.item :show, @area.name, area_path(@area) do |area|
+          if can? :destroy, @area
+            area.item :destroy, t('general.destroy'), area_path(@area), method: :delete, confirm: t('general.questions.are_you_sure')
+          end
+          
+          area.item :show, t('general.details'), "#{area_path(@area)}#top"
+          area.item :edit, t('general.edit'), edit_area_path(@area) if can? :edit, @area
+          area.item :users, t('users.index.title'), area_users_path(@area)
+          area.item :projects, t('projects.index.title'), area_projects_path(@area)  
+        end
+      end
+    end
+    
+    primary.item :products, t('products.index.title'), products_path do |products|
+      products.item :new, t('general.new'), new_product_path
+      
+      unless (@product.new_record? rescue true)
+        products.item :show, @product.name, product_path(@product) do |product|
+          if can? :edit, @product
+            product.item :destroy, t('general.destroy'), product_path(@product), method: :delete, confirm: t('general.questions.are_you_sure')
+          end
+          
+          product.item :show, t('general.details'), "#{product_path(@product)}#top"
+          product.item :edit, t('general.edit'), edit_product_path(@product)  if can? :edit, @product
+            
+          product.item :projects, t('projects.index.title'), product_projects_path(@product)  
+        end
+      end
+    end
+    
+    primary.item :projects, t('projects.index.title'), projects_path do |projects|
+      projects.item :new, t('general.new'), new_project_path
+      
+      unless (@project.new_record? rescue true)
+        projects.item :show, @project.name, project_path(@project) do |project|
+          if can? :destroy, @project
+            project.item :destroy, t('general.destroy'), project_path(@project), method: :delete, confirm: t('general.questions.are_you_sure')
+          end
+          
+          project.item :show, t('general.details'), "#{project_path(@project)}#top"
+          project.item :edit, t('general.edit'), edit_project_path(@project) if can? :edit, @project
+          
+          project.item :users, t('users.index.title'), project_users_path(@project)  
+          
+          project.item :vacancies, t('vacancies.index.title'), project_vacancies_path(@project) do |vacancy|
+            vacancy.item :new, t('general.new'), new_project_vacancy_path(@project)
+          end
+          
+          project.item :stories, t('stories.index.title'), project_stories_path(@project) do |stories|
+            stories.item :new, t('general.new'), new_project_story_path(@project)
+
+            unless (@story.new_record? rescue true)
+              stories.item(:show, @story.name, story_path(@story)) do |story|
+                if can? :destroy, @story
+                  story.item :destroy, t('general.destroy'), story_path(@story), method: :delete, confirm: t('general.questions.are_you_sure')
+                end
+                
+                story.item :show, t('general.details'), "#{story_path(@story)}#top"
+                story.item :edit, t('general.edit'), edit_story_path(@story) if can? :edit, @story
+
+                story.item :steps, t('general.steps'), setup_tasks_story_path(@story) do |steps|
+                  steps.item :setup_tasks, t('stories.steps.setup_tasks.title'), setup_tasks_story_path(@story)
+                  steps.item :activate, t('general.events.activate'), activate_story_path(@story)
+                end
+                                
+                story.item :tasks, t('tasks.index.title'), story_tasks_path(@story) do |tasks|
+                  tasks.item :new, t('general.new'), new_story_task_path(@story)
+      
+                  unless (@task.new_record? rescue true)
+                    tasks.item(:show, @task.name, task_path(@task)) do |task|
+                      if can? :destroy, @task
+                        task.item :destroy, t('general.destroy'), task_path(@task), method: :delete, confirm: t('general.questions.are_you_sure')
+                      end
+                      
+                      task.item :show, t('general.details'), "#{task_path(@task)}#top"
+                      task.item :edit, t('general.edit'), edit_task_path(@task) if can? :edit, @task
+                      
+                      task.item :results, t('results.index.title'), task_results_path(@task) do |results|
+                        results.item :new, t('general.new'), new_task_result_path(@task)
+            
+                        unless (@result.new_record? rescue true)
+                          results.item(:show, @result.name, result_path(@result)) do |result|
+                            if can? :destroy, @result
+                              result.item :destroy, t('general.destroy'), result_path(@result), method: :delete, confirm: t('general.questions.are_you_sure')
+                            end
+                            
+                            result.item :show, t('general.details'), "#{result_path(@result)}#top"
+                            result.item :edit, t('general.edit'), edit_result_path(@result) if can? :edit, @result
+                            
+                            result.item :comments, t('comments.index.title'), "#{story_path(@story)}#comments" do |comments|
+                              comments.item(:new, t('general.new'), new_story_comment_path(@story)) if @comment
+                              
+                              if can? :edit, @comment
+                                comments.item(:edit, t('general.edit'), edit_comment_path(@comment)) if @comment.try(:id)
+                              end
+                            end 
+                          end
+                        end
+                      end
+                      
+                      task.item :comments, t('comments.index.title'), "#{story_path(@story)}#comments" do |comments|
+                        comments.item(:new, t('general.new'), new_story_comment_path(@story)) if @comment
+                        
+                        if @comment.try(:id) && can?(:edit, @comment)
+                          comments.item(:edit, t('general.edit'), edit_comment_path(@comment))
+                        end
+                      end 
+                    end
+                  end
+                end
+                
+                story.item :comments, t('comments.index.title'), "#{story_path(@story)}#comments" do |comments|
+                  comments.item(:new, t('general.new'), new_story_comment_path(@story)) if @comment
+                  
+                  if @comment.try(:id) && can?(:edit, @comment)
+                    comments.item(:edit, t('general.edit'), edit_comment_path(@comment))
+                  end
+                end 
+              end
+            end
+          end
+          
+          project.item :comments, t('comments.index.title'), "#{project_path(@project)}#comments" do |comments|
+            comments.item(:new, t('general.new'), new_project_comment_path(@project)) if @comment
+            
+            if @comment.try(:id) && can?(:edit, @comment)
+              comments.item(:edit, t('general.edit'), edit_comment_path(@comment))
+            end
+          end
+        end
+      end  
+    end
+    
+    primary.item :vacancies, t('vacancies.index.title'), vacancies_path do |vacancies|
+      vacancies.item :new, t('general.new'), new_vacancy_path
+      
+      unless (@vacancy.new_record? rescue true)
+        vacancies.item :show, "#{@vacancy.name} @ #{@vacancy.project.name}", vacancy_path(@vacancy) do |vacancy|
+          
+          if can? :destroy, @vacancy
+            vacancy.item :destroy, t('general.destroy'), vacancy_path(@vacancy), method: :delete, confirm: t('general.questions.are_you_sure')
+          end
+          
+          vacancy.item :show, t('general.details'), "#{vacancy_path(@vacancy)}#top"
+          vacancy.item :edit, t('general.edit'), edit_vacancy_path(@vacancy) if can? :edit, @vacancy
+          
+          vacancy.item :candidatures, t('candidatures.index.title'), vacancy_candidatures_path(@vacancy) do |candidatures|
+            candidatures.item :new, t('general.new'), new_vacancy_candidature_path(@vacancy)
+          
+            unless (@candidature.new_record? rescue true)
+              candidatures.item(
+                :show, t('activerecord.models.candidature') + " of #{@candidature.user.name} @ #{@candidature.vacancy.project.name}", 
+                candidature_path(@candidature) 
+              ) do |candidature|
+                if can? :destroy, @candidature
+                  candidature.item :destroy, t('general.destroy'), candidature_path(@candidature), method: :delete, confirm: t('general.questions.are_you_sure')
+                end
+                
+                candidature.item :show, t('general.details'), "#{candidature_path(@candidature)}#top"
+                candidature.item :edit, t('general.edit'), edit_candidature_path(@candidature) if can? :edit, @candidature
+                
+                candidature.item :comments, t('comments.index.title'), "#{candidature_path(@candidature)}#comments" do |comments|
+                  comments.item(:new, t('general.new'), new_candidature_comment_path(@candidature)) if @comment
+                  
+                  if @comment.try(:id) && can?(:edit, @comment)
+                    comments.item(:edit, t('general.edit'), edit_comment_path(@comment))
+                  end
+                end 
+              end
+            end
+          end
+           
+          vacancy.item :comments, t('comments.index.title'), "#{vacancy_path(@vacancy)}#comments" do |comments|
+            comments.item(:new, t('general.new'), new_vacancy_comment_path(@vacancy)) if @comment && !@candidature
+            
+            if @comment.try(:id) && can?(:edit, @comment)
+              comments.item(:edit, t('general.edit'), edit_comment_path(@comment)) 
+            end
+          end 
+        end
+      end  
+    end
+    
+    primary.item :users, t('users.index.title'), users_path do |users|
+      unless (@user.new_record? rescue true) || current_user.try(:id) == @user.id
+        users.item :show, t('general.details'), "#{user_path(@user)}#top"
+        
+        users.item :projects, t('projects.index.title'), user_projects_path(@user)
+        users.item :candidatures, t('candidatures.index.title'), user_candidatures_path(@user)
+      end
+    end
+ 
+    if user_signed_in?
+      primary.item :workflow, t('workflow.index.title'), workflow_path do |workflow|
+        workflow.item :project_owner, t('workflow.project_owner.index.title'), workflow_project_owner_index_path do |project_owner|
+          project_owner.item :vacancies, t('vacancies.index.title'), open_workflow_vacancies_path do |vacancies|
+            Vacancy::STATES.each do |state|
+              vacancies.item state, t("vacancies.show.states.#{state}"), eval("#{state}_workflow_vacancies_path")
+            end
+          end
+            
+          project_owner.item :candidatures, t('candidatures.index.title'), new_workflow_candidatures_path do |candidatures|
+            Candidature::STATES.each do |state|
+              candidatures.item state, t("candidatures.show.states.#{state}"), eval("#{state}_workflow_candidatures_path")
+            end
+          end
+        end
+        
+        workflow.item :user, t('workflow.user.index.title'), workflow_user_index_path do |user|
+          { 
+            'no-name' => t('workflow.user.products.no_name.title')
+          }.each do |slug, text|
+            user.item slug.gsub('-', '_').to_sym, text, product_workflow_user_index_path(slug) do |product|
+              product_slug = @story ? (@story.product.try(:to_param) || 'no-name') : 'no-name'
+              
+              unless (@story.new_record? rescue true) || product_slug != slug
+                product.item(:show, @story.name, story_path(@story)) do |story|
+                  story.item :show, t('general.details'), "#{story_path(@story)}#top"
+                
+                  story.item :tasks, t('tasks.index.title'), tasks_workflow_user_index_path(@story) do |tasks|
+                    unless (@task.new_record? rescue true)
+                      tasks.item(:edit, @task.name, edit_task_workflow_user_index_path(@task))
+                    end
+                  end
+                end
+              end
+              
+              product.item :next_task, t('workflow.user.tasks.next.title'), next_task_workflow_user_index_path('text-creation')
+            end
+          end
+        end
+      end
+            
+      primary.item :profile, t('users.show.title'), user_path(current_user) do |profile|
+        profile.item :show, t('users.show.title'), user_path(current_user) do |user|
+          user.item :show, t('users.show.title'), "#{user_path(current_user)}#top"
+          user.item :settings, t('users.edit.title'), edit_user_path(current_user)
+          user.item :preferences, t('users.preferences.title'), preferences_user_path(current_user)
+          user.item :projects, t('projects.index.title'), user_projects_path(current_user)
+          user.item :candidatures, t('candidatures.index.title'), user_candidatures_path(current_user)
+        end
+      end
+      
+      primary.item :sign_out, t('authentication.sign_out'), destroy_user_session_path, method: :delete
+    else
+      primary.item :authentication, t('authentication.title'), new_user_session_path do |authentication|
+        authentication.item :sign_in, t('authentication.sign_in'), new_user_session_path
+        #authentication.item :rpx_sign_in, t('authentication.rpx_sign_in'), 'a' # link_to_rpx
+        authentication.item :sign_up, t('authentication.sign_up'), new_user_registration_path
+      end
+    end
+  end
+end

data/lib/generators/voluntary/product_dummy/templates/config/mongoid.yml

@@ -0,0 +1,78 @@
+development:
+  # Configure available database sessions. (required)
+  sessions:
+    # Defines the default session. (required)
+    default:
+      # Defines the name of the default database that Mongoid can connect to.
+      # (required).
+      database: volontariat_development
+      # Provides the hosts the default session can connect to. Must be an array
+      # of host:port pairs. (required)
+      hosts:
+        - localhost:27017
+      options:
+        # Change whether the session persists in safe mode by default.
+        # (default: false)
+        # safe: false
+
+        # Change the default consistency model to :eventual or :strong.
+        # :eventual will send reads to secondaries, :strong sends everything
+        # to master. (default: :eventual)
+        consistency: :strong
+  # Configure Mongoid specific options. (optional)
+  options:
+    # Configuration for whether or not to allow access to fields that do
+    # not have a field definition on the model. (default: true)
+    # allow_dynamic_fields: true
+
+    # Enable the identity map, needed for eager loading. (default: false)
+    # identity_map_enabled: false
+
+    # Includes the root model name in json serialization. (default: false)
+    # include_root_in_json: false
+
+    # Include the _type field in serializaion. (default: false)
+    # include_type_for_serialization: false
+
+    # Preload all models in development, needed when models use
+    # inheritance. (default: false)
+    # preload_models: false
+
+    # Protect id and type from mass assignment. (default: true)
+    # protect_sensitive_fields: true
+
+    # Raise an error when performing a #find and the document is not found.
+    # (default: true)
+    # raise_not_found_error: true
+
+    # Raise an error when defining a scope with the same name as an
+    # existing method. (default: false)
+    # scope_overwrite_exception: false
+
+    # Skip the database version check, used when connecting to a db without
+    # admin access. (default: false)
+    # skip_version_check: false
+
+    # User Active Support's time zone in conversions. (default: true)
+    # use_activesupport_time_zone: true
+
+    # Ensure all times are UTC in the app side. (default: false)
+    # use_utc: false
+test:
+  sessions:
+    default:
+      database: volontariat_test
+      hosts:
+        - localhost:27017
+      options:
+        consistency: :strong
+        
+production:
+  sessions:
+    default:
+      database: volontariat_production
+      hosts:
+        - localhost:27017
+      options:
+        consistency: :strong
+        

data/lib/generators/voluntary/product_dummy/templates/config/routes.rb

@@ -0,0 +1,3 @@
+Dummy::Application.routes.draw do
+  root to: 'home#index'
+end

data/lib/generators/voluntary/product_dummy/templates/features/step_definitions/area_behaviour_steps.rb

@@ -0,0 +1,17 @@
+Then /^I can't edit areas$/ do
+  steps %{
+    Given an area named "area 1"
+    When I go to the edit area page
+    Then I should see "Access denied"
+  }
+end
+
+Then /^I can't delete areas$/ do
+  steps %{
+    Given an area named "area 1" 
+    When I am on the area page
+    Then I should not see "Actions"
+  }
+end
+
+

data/lib/generators/voluntary/product_dummy/templates/features/step_definitions/area_steps.rb

@@ -0,0 +1,11 @@
+Given /^an area named "([^\"]*)"$/ do |name|
+  # WORKAROUND: get rid of area query. Don't know why it doesn't work without (e.g. /roles/2_users/projects.feature)
+  @area = Area.where(name: name).first || Factory(:area, name: name)
+  @area.reload
+end
+
+Then /^I should see the following areas:$/ do |expected_table|
+  rows = find("table").all('tr')
+  table = rows.map { |r| r.all('th,td').map { |c| c.text.strip } }
+  expected_table.diff!(table)
+end

data/lib/generators/voluntary/product_dummy/templates/features/step_definitions/candidature_steps.rb

@@ -0,0 +1,34 @@
+module CandidatureFactoryMethods
+  def set_candidature_defaults(attributes)
+    attributes[:user_id] ||= @me.id unless attributes[:user] || attributes[:user_id] || !@me
+    attributes[:vacancy_id] ||= Vacancy.last.id unless attributes[:vacancy_id] || Vacancy.all.none?
+    attributes[:offeror_id] ||= Vacancy.find(attributes[:vacancy_id]).project.user_id if attributes[:vacancy_id]
+  end
+  
+  def new_candidature(name, state = nil)
+    attributes = { name: name }
+    attributes[:state] = state if state
+    
+    set_candidature_defaults(attributes)
+    
+    @candidature = Factory(:candidature, attributes)
+    
+    @candidature.reload
+  end
+end
+
+World(CandidatureFactoryMethods)
+
+Given /^a candidature named "([^\"]*)"$/ do |name|
+  new_candidature(name)
+end
+
+Given /^a candidature named "([^\"]*)" with state "([^\"]*)"$/ do |name,state|
+  new_candidature(name, state)
+end
+
+Then /^I should see the following candidatures:$/ do |expected_table|
+  rows = find('table').all('tr')
+  table = rows.map { |r| r.all('th,td').map { |c| c.text.strip } }
+  expected_table.diff!(table)
+end

data/lib/generators/voluntary/product_dummy/templates/features/step_definitions/comment_behaviour_steps.rb

@@ -0,0 +1,23 @@
+When /^I fill out a comment form$/ do
+  fill_in 'Subject', with: 'Comment 1'
+  fill_in 'Text', with: 'Dummy 1'
+end
+
+When /^I fill out a comment's comment form$/ do
+  fill_in 'Subject', with: 'Comment 2'
+  fill_in 'Text', with: 'Dummy 2'
+end
+
+Then /^I should see the comment$/ do
+  steps %{
+    Then I should see "Comment 1"
+    And I should see "Dummy 1"
+  }
+end
+
+Then /^I should see the comment's comment$/ do
+  page.should have_xpath(
+    '//div[@class="nested_comments"]//div[@class="comment"]//div[@class="content"]//p',
+    text: 'Dummy 2'
+  )
+end

data/lib/generators/voluntary/product_dummy/templates/features/step_definitions/comment_steps.rb

@@ -0,0 +1,25 @@
+Given /^a comment$/ do
+  attributes = { commentable: @project || @vacancy || @candidature }
+  attributes[:user_id] ||= @me.id if @me
+  @comment = Factory(:comment, attributes)
+  @comment.reload
+end
+
+When /^I reply the (\d+)(?:st|nd|rd|th) comment$/ do |pos|
+  find(:xpath, "//a[@class='new_comment'][#{pos.to_i}]").click
+end
+
+When /^I edit the (\d+)(?:st|nd|rd|th) comment$/ do |pos|
+  find(:xpath, "//a[@class='edit_comment'][#{pos.to_i}]").click
+end
+
+When /^I delete the (\d+)(?:st|nd|rd|th) comment$/ do |pos|
+  page.execute_script 'window.confirm = function () { return true }'
+  find(:xpath, "//a[@class='destroy_comment'][#{pos.to_i}]").click
+end
+
+Then /^I should see the following comments:$/ do |expected_table|
+  expected_table.hashes.each do |hash|
+    steps %{Then I should see "#{hash['Name']}"}
+  end  
+end

data/lib/generators/voluntary/product_dummy/templates/features/step_definitions/email_steps.rb

@@ -0,0 +1,89 @@
+Before do
+  ActionMailer::Base.deliveries.clear
+end
+
+Given /^I have an empty inbox$/ do
+ ActionMailer::Base.deliveries.clear
+end
+
+Then /^(an|no) email should have been sent((?: |and|with|from "[^"]+"|to "[^"]+"|the subject "[^"]+"|the body "[^"]+"|the attachments "[^"]+")+)$/ do |mode, query|
+  conditions = {}
+  conditions[:to] = $1 if query =~ /to "([^"]+)"/
+  conditions[:from] = $1 if query =~ /from "([^"]+)"/
+  conditions[:subject] = $1 if query =~ /the subject "([^"]+)"/
+  conditions[:body] = $1 if query =~ /the body "([^"]+)"/
+  conditions[:attachments] = $1 if query =~ /the attachments "([^"]+)"/
+  
+  @mail = TestMails.find(conditions)
+  expectation = mode == 'no' ? 'should_not' : 'should'
+  @mail.send(expectation, be_present)
+end
+
+When /^I follow the (first|second|third)? ?link in the email$/ do |index_in_words|
+  # Caveat: will not only take a-href but also img-src and other http-values
+  mail = @mail || ActionMailer::Base.deliveries.last
+  # index = { nil => 0, 'first' => 0, 'second' => 1, 'third' => 2 }[index_in_words]
+  # visit mail.body.scan(Patterns::URL)[index][2]
+  visit mail.body.to_s.scan(/http(?:s?):\/\/[^"\s]+/).send(index_in_words).split(':3000').last
+end
+
+Then /^no email should have been sent$/ do
+  ActionMailer::Base.deliveries.should be_empty
+end
+ 
+Then /^show me the emails$/ do
+  #raise ActionMailer::Base.deliveries.length.inspect
+  puts "emails count:" + ActionMailer::Base.deliveries.length.inspect
+  
+  ActionMailer::Base.deliveries.each do |mail|
+    p [mail.from, mail.to, mail.subject, mail.body]
+  end
+end
+
+Then /^that mail should have "([^"]*)" in the body$/ do |word|
+  @mail.body.include?(word).should be_true
+end
+# 
+# 
+class TestMails
+  class << self
+
+    attr_accessor :user_identity
+
+    def find(conditions)
+      ActionMailer::Base.deliveries.detect do |mail|
+        [ conditions[:to].nil? || mail.to.include?(resolve_email conditions[:to]),
+          conditions[:from].nil? || mail.from.include?(resolve_email conditions[:from]),
+          conditions[:subject].nil? || mail.subject.include?(conditions[:subject]),
+          conditions[:body].nil? || mail.body.include?(conditions[:body]),
+          conditions[:attachments].nil? || conditions[:attachments].split(/\s*,\s*/).sort == Array(mail.attachments).collect(&:original_filename).sort
+        ].all?
+      end.tap do |mail|
+        puts "Die Mail: #{mail}" 
+        log(mail)
+      end
+    end
+
+    def resolve_email(identity)
+      if identity =~ /^.+\@.+$/
+        identity
+      else
+        User.send("find_by_#{user_identity || 'email'}!", identity).email
+      end
+    end
+
+    def log(mail)
+      puts "Aufruf: #{mail}" 
+      if mail.present?
+        File.open("log/test_mails.log", "a") do |file|
+          file << "From: #{mail.from}\n"
+          file << "To: #{mail.to.join(', ')}\n"
+          file << "Subject: #{mail.subject}\n\n"
+          file << mail.body
+          file << "\n-------------------------\n\n"
+        end
+      end
+    end
+
+  end
+end

data/lib/generators/voluntary/product_dummy/templates/features/step_definitions/factory_steps.rb

@@ -0,0 +1,120 @@
+module FactoryMethods
+  def create_from_table(model_name, table, extra = {})
+    factory_name = model_name.gsub(/\W+/, '_').downcase.singularize.to_sym
+    is_singular = model_name.to_s.singularize == model_name.to_s
+    
+    hashes = if is_singular
+       if table.kind_of?(Hash)
+         [table]
+       else
+         [table.rows_hash]
+       end
+     elsif table.is_a?(Array)
+       table
+     else
+       table.hashes
+     end
+            
+    @klass = factory_name.to_s.classify.constantize
+    @they = hashes.map do |hash|
+      hash = hash.merge(extra).inject({}) do |h,(k,v)|
+        k = k.gsub(/\W+/,'_')
+        
+        # mongo db model classes are not responding to serialized attributes
+        # TODO: take care of serialized attributes in future mongo db model implementations here
+        if @klass.respond_to?(:serialized_attributes) && @klass.serialized_attributes[k] == Array
+          v = v.split(/\s*,\s*/)
+        end
+        
+        h.update(k.to_sym => v)
+      end
+      
+      hash.keys.each do |attribute|
+        set_value(hash, attribute)
+      end
+      
+      eval("set_#{factory_name}_defaults(hash)") if "#{factory_name.to_s.classify}FactoryMethods".constantize rescue nil
+      
+      object = nil
+      
+      object = @klass.where(name: hash[:name]).first if hash.has_key? :name
+      object = object ? object : Factory.build(factory_name, hash)
+      
+      yield object if block_given?
+      
+      object.save!
+      
+      object
+    end
+    
+    if is_singular
+      @it = @they.last
+      instance_variable_set("@#{factory_name}", @it)
+    end
+  end
+  
+  private
+  
+  def set_value(hash, attribute)
+    value = hash[attribute]
+    
+    if value.match '@' 
+      if eval(value)
+        hash[attribute] = eval(value) 
+      else
+        hash.delete attribute
+      end
+    elsif @klass.reflections.values.select{|v| v.macro == :belongs_to }.map(&:name).include? attribute
+      reflection_value = @klass.reflections.values.select{|v| v.name == attribute }.first
+      
+      if reflection_value.options[:polymorphic]
+        polymorphic_type = "#{@klass.name}::#{attribute.to_s.upcase}_TYPES".constantize.first
+        resource = polymorphic_type.classify.constantize.find_by_name(value)
+        hash[attribute] = resource || create_from_table(polymorphic_type.tableize, [{ 'name' => value }])
+      else
+        resource = attribute.to_s.classify.constantize.find_by_name(value)
+        hash[attribute] = resource || create_from_table(attribute.to_s.tableize, [{ 'name' => value }])
+      end
+    end
+  end
+end
+
+World(FactoryMethods)
+
+Given %r{^I have a (.+)$} do |model_name|
+  create_from_table(model_name, {}, 'user' => @me)
+end
+
+Given %r{^I have the following (.+):$} do |child, table|
+  step "that me has the following #{child}:", table
+end
+
+Given %r{^the following (.+):$} do |model_name, table|
+  create_from_table(model_name, table)
+end
+
+Given %r{^that (.+) has the following (.+):$} do |parent, child, table|
+  child= child.gsub(/\W+/,'_')
+  parent = parent.gsub(/\W+/,'_').downcase.sub(/^_/, '')
+  parent_instance = instance_variable_get("@#{parent}")
+  parent_class = parent_instance.class
+  
+  if assoc = parent_class.reflect_on_association(child.to_sym) || parent_class.reflect_on_association(child.pluralize.to_sym)
+    parent = (assoc.options[:as] || parent).to_s
+    child = (assoc.options[:class_name] || child).to_s
+  end
+  
+  if child.classify.constantize.method_defined?(parent.pluralize)
+    create_from_table(child, table, parent.pluralize => [parent_instance])
+  elsif child.classify.constantize.method_defined?(parent)
+    create_from_table(child, table, parent => parent_instance)
+  else
+    create_from_table(child, table)
+    
+    if assoc.macro == :has_many
+      parent_instance.send("#{assoc.name}=", @they)
+    else
+      parent_instance.send("#{assoc.name}=", @they.first)
+    end
+  end
+end