fabrication 1.1.0 → 1.2.0

data/lib/fabrication/cucumber.rb

@@ -0,0 +1,104 @@
+module Fabrication
+  module Cucumber
+    class StepFabricator
+      attr_reader :model
+
+      def initialize(model_name, opts ={})
+        @model = dehumanize(model_name)
+        @fabricator = @model.singularize.to_sym
+        @parent_name = opts.delete(:parent)
+      end
+
+      def from_table(table, extra={})
+        hashes = singular? ? [table.rows_hash] : table.hashes
+        hashes.map do |hash|
+          make(parameterize_hash(hash).merge(extra))
+        end.tap {|o| remember(o) }
+      end
+
+      def n(count, attrs={})
+        count.times.map { make(attrs) }.tap {|o| remember(o) }
+      end
+
+      def has_many(children)
+        instance = Fabrications[@fabricator]
+        children = dehumanize(children)
+        [Fabrications[children]].flatten.each do |child|
+          child.send("#{klass.to_s.underscore.downcase}=", instance)
+          child.respond_to?(:save!) && child.save!
+        end
+      end
+
+      def parent
+        return unless @parent_name
+        Fabrications[dehumanize(@parent_name)]
+      end
+
+      def klass
+        schematic.klass
+      end
+
+      private
+
+      def remember(objects)
+        if singular?
+          Fabrications[@fabricator] = objects.last
+        else
+          Fabrications[@model.to_sym] = objects
+        end
+      end
+
+      def singular?
+        @model == @model.singularize
+      end
+
+      def schematic
+        Fabrication::Fabricator.schematics[@fabricator]
+      end
+
+      def dehumanize(string)
+        string.gsub(/\W+/,'_').downcase
+      end
+
+      def parameterize_hash(hash)
+        hash.inject({}) {|h,(k,v)| h.update(dehumanize(k).to_sym => v)}
+      end
+
+      def make(attrs={})
+        Fabricate(@fabricator, attrs.merge(parentship))
+      end
+
+      def parentship
+        return {} unless parent
+        parent_class_name = parent.class.to_s.underscore
+
+        parent_instance = parent
+        unless klass.new.respond_to?("#{parent_class_name}=")
+          parent_class_name = parent_class_name.pluralize
+          parent_instance = [parent]
+        end
+
+        { parent_class_name => parent_instance }
+      end
+
+    end
+
+    module Fabrications
+      @@fabrications = {}
+
+      def self.[](fabricator)
+        @@fabrications[fabricator.to_sym]
+      end
+
+      def self.[]=(fabricator, fabrication)
+        @@fabrications[fabricator.to_sym] = fabrication
+      end
+    end
+  end
+end
+
+module FabricationMethods
+  def fabrications
+    Fabrication::Cucumber::Fabrications
+  end
+end

data/lib/fabrication/sequencer.rb

@@ -2,10 +2,13 @@ class Fabrication::Sequencer
 
   DEFAULT = :_default
 
-  def self.sequence(name=DEFAULT, start=0)
+  def self.sequence(name=DEFAULT, start=0, &block)
     idx = sequences[name] ||= start
-
-    (block_given? ? yield(idx) : idx).tap do
+    if block_given?
+      sequence_blocks[name] = block.to_proc
+    else
+      sequence_blocks[name] ||= lambda { |i| i }
+    end.call(idx).tap do
       sequences[name] += 1
     end
   end
@@ -14,4 +17,7 @@ class Fabrication::Sequencer
     @sequences ||= {}
   end
 
+  def self.sequence_blocks
+    @sequence_blocks ||= {}
+  end
 end

data/lib/fabrication/version.rb

@@ -1,3 +1,3 @@
 module Fabrication
-  VERSION = '1.1.0'
+  VERSION = '1.2.0'
 end

data/lib/rails/generators/fabrication/cucumber_steps/templates/fabrication_steps.rb

@@ -1,103 +1,47 @@
-module FabricationMethods
+require 'fabrication/cucumber'
 
-  def create_from_table(model_name, table, extra = {})
-    model_name = dehumanize(model_name)
-    fabricator_name = generate_fabricator_name(model_name)
-    is_singular = model_name.to_s.singularize == model_name.to_s
-    hashes = is_singular ? [table.rows_hash] : table.hashes
-    @they = hashes.map do |hash|
-      hash = parameterize_hash(hash.merge(extra))
-      Fabricate(fabricator_name, hash)
-    end
-    instantize(fabricator_name, is_singular)
-  end
-
-  def create_with_default_attributes(model_name, count, extra = {})
-    fabricator_name = generate_fabricator_name(dehumanize(model_name))
-    is_singular = count == 1
-    @they = count.times.map { Fabricate(fabricator_name, extra) }
-    instantize(fabricator_name, is_singular)
-  end
-
-  def dehumanize(string)
-    string.gsub(/\W+/,'_').downcase
-  end
-
-  def generate_fabricator_name(model_name)
-    model_name.singularize.to_sym
-  end
-
-  def get_class(model_name)
-    fabricator_name = generate_fabricator_name(model_name)
-    Fabrication::Fabricator.schematics[fabricator_name].klass
-  end
-
-  def instantize(fabricator_name, is_singular)
-    if is_singular
-      @it = @they.last
-      instance_variable_set("@#{fabricator_name}", @it)
-    else
-      instance_variable_set("@#{fabricator_name.to_s.pluralize}", @they)
-    end
-  end
-
-  def parameterize_hash(hash)
-    hash.inject({}) {|h,(k,v)| h.update(dehumanize(k).to_sym => v)}
-  end
-
-  def parentship(parent, child)
-    parent_instance = instance_variable_get("@#{dehumanize(parent)}")
-    parent_class_name = parent_instance.class.to_s.underscore
-    child_class = get_class(dehumanize(child))
-
-    if child_class && !child_class.new.respond_to?("#{parent_class_name}=")
-      parent_class_name = parent_class_name.pluralize
-      parent_instance = [parent_instance]
-    end
-
-    { parent_class_name => parent_instance }
-  end
-
-  def class_from_model_name(model_name)
-    eval(dehumanize(model_name).singularize.classify)
-  end
+World(FabricationMethods)
 
+def with_ivars(fabricator)
+  @they = yield fabricator
+  instance_variable_set("@#{fabricator.model}", @they)
 end
 
-World(FabricationMethods)
-
 Given /^(\d+) ([^"]*)$/ do |count, model_name|
-  create_with_default_attributes(model_name, count.to_i)
+  with_ivars Fabrication::Cucumber::StepFabricator.new(model_name) do |fab|
+    fab.n(count.to_i)
+  end
 end
 
 Given /^the following ([^"]*):$/ do |model_name, table|
-  create_from_table(model_name, table)
+  with_ivars Fabrication::Cucumber::StepFabricator.new(model_name) do |fab|
+    fab.from_table(table)
+  end
 end
 
 Given /^that ([^"]*) has the following ([^"]*):$/ do |parent, child, table|
-  create_from_table(child, table, parentship(parent, child))
+  with_ivars Fabrication::Cucumber::StepFabricator.new(child, :parent => parent) do |fab|
+    fab.from_table(table)
+  end
 end
 
 Given /^that ([^"]*) has (\d+) ([^"]*)$/ do |parent, count, child|
-  create_with_default_attributes(child, count.to_i, parentship(parent, child))
+  with_ivars Fabrication::Cucumber::StepFabricator.new(child, :parent => parent) do |fab|
+    fab.n(count.to_i)
+  end
 end
 
-Given /^(?:that|those) (.*) belongs? to that (.*)$/ do |child_or_children, parent|
-  parent = dehumanize(parent)
-  parent_instance = instance_variable_get("@#{parent}")
-  child_or_children = dehumanize(child_or_children)
-
-  child_or_children_instance = instance_variable_get("@#{child_or_children}")
-  [child_or_children_instance].flatten.each do |child_instance|
-    child_instance.send("#{parent}=", parent_instance)
-    child_instance.save
+Given /^(?:that|those) (.*) belongs? to that (.*)$/ do |children, parent|
+  with_ivars Fabrication::Cucumber::StepFabricator.new(parent) do |fab|
+    fab.has_many(children)
   end
 end
 
 Then /^I should see (\d+) ([^"]*) in the database$/ do |count, model_name|
-  get_class(dehumanize(model_name)).count.should == count.to_i
+  Fabrication::Cucumber::StepFabricator.new(model_name).klass.count.should == count.to_i
 end
 
 Then /^I should see the following (.*) in the database:$/ do |model_name, table|
-  get_class(dehumanize(model_name)).where(table.rows_hash).count.should == 1
+  klass = Fabrication::Cucumber::StepFabricator.new(model_name).klass
+  klass.where(table.rows_hash).count.should == 1
 end

data/spec/fabrication/cucumber_spec.rb

@@ -0,0 +1,116 @@
+require 'spec_helper'
+require 'fabrication/cucumber'
+
+describe Fabrication::Cucumber do
+  include described_class
+
+  let(:name) { 'dogs' }
+
+  describe '#klass' do
+    context 'with a schematic for class "Boom"' do
+      subject { StepFabricator.new(name).klass }
+      let(:fabricator_name) { :dog }
+
+      before do
+        Fabrication::Fabricator.schematics.stub(:[])
+          .with(fabricator_name).and_return(stub(:klass => "Boom"))
+      end
+
+      it { should == "Boom" }
+
+      context "given a human name" do
+        let(:name) { "weiner dogs" }
+        let(:fabricator_name) { :weiner_dog }
+        it { should == "Boom" }
+      end
+
+      context "given a titlecase human name" do
+        let(:name) { "Weiner Dog" }
+        let(:fabricator_name) { :weiner_dog }
+        it { should == "Boom" }
+      end
+    end
+  end
+
+  describe "#n" do
+    let(:n) { 3 }
+    let(:fabricator) { StepFabricator.new(name) }
+
+    it "fabricates n times" do
+      Fabrication::Fabricator.should_receive(:generate).with(:dog, anything, {}).exactly(n).times
+      fabricator.n n
+    end
+
+    it "fabricates with attrs" do
+      Fabrication::Fabricator.should_receive(:generate)
+        .with(anything, anything, :collar => 'red').at_least(1)
+      fabricator.n n, :collar => 'red'
+    end
+
+    context 'with a plural subject' do
+      let(:name) { 'dogs' }
+      it 'remembers' do
+        Fabrication::Fabricator.stub(:generate).and_return("dog1", "dog2", "dog3")
+        fabricator.n n
+        Fabrications[name].should == ["dog1", "dog2", "dog3"]
+      end
+    end
+
+    context 'with a singular subject' do
+      let(:name) { 'dog' }
+      it 'remembers' do
+        Fabrication::Fabricator.stub(:generate).and_return("dog1")
+        fabricator.n 1
+        Fabrications[name].should == 'dog1'
+      end
+    end
+
+  end
+
+  describe '#from_table' do
+    it 'maps column names to attribute names' do
+      table = stub(:hashes => [{ 'Favorite Color' => 'pink' }])
+      Fabrication::Fabricator.should_receive(:generate)
+        .with(anything, anything, :favorite_color => 'pink')
+      StepFabricator.new('bears').from_table(table)
+    end
+
+    context 'with a plural subject' do
+      let(:table) { double("ASTable", :hashes => hashes) }
+      let(:hashes) do
+        [{'some' => 'thing'},
+         {'some' => 'panother'}]
+      end
+      it 'fabricates with each rows attributes' do
+        Fabrication::Fabricator.should_receive(:generate)
+          .with(:dog, anything, {:some => 'thing'})
+        Fabrication::Fabricator.should_receive(:generate)
+          .with(:dog, anything, {:some => 'panother'})
+        StepFabricator.new(name).from_table(table)
+      end
+      it 'remembers' do
+        Fabrication::Fabricator.stub(:generate).and_return('dog1', 'dog2')
+        StepFabricator.new(name).from_table(table)
+        Fabrications[name].should == ["dog1", "dog2"]
+      end
+    end
+
+    context 'singular' do
+      let(:name) { 'dog' }
+      let(:table) { double("ASTable", :rows_hash => rows_hash) }
+      let(:rows_hash) do
+        {'some' => 'thing'}
+      end
+      it 'fabricates with each row as an attribute' do
+        Fabrication::Fabricator.should_receive(:generate).with(:dog, anything, {:some => 'thing'})
+        StepFabricator.new(name).from_table(table)
+      end
+      it 'remembers' do
+        Fabrication::Fabricator.stub(:generate).and_return('dog1')
+        StepFabricator.new(name).from_table(table)
+        Fabrications[name].should == "dog1"
+      end
+    end
+  end
+
+end

data/spec/fabrication/sequencer_spec.rb

@@ -66,6 +66,33 @@ describe Fabrication::Sequencer do
       end.should == "user2@example.com"
     end
 
+    context 'and then without a block' do
+      it 'remembers the original block' do
+        Fabricate.sequence :ordinal, &:ordinalize
+        Fabricate.sequence(:ordinal).should == "1st"
+      end
+      context 'and then with a new block' do
+        it 'evaluates the new block' do
+          Fabricate.sequence(:ordinal) do |i|
+            i ** 2
+          end.should == 4
+        end
+        it 'remembers the new block' do
+          Fabricate.sequence(:ordinal).should == 9
+        end
+      end
+    end
+  end
+  context 'with two sequences declared with blocks' do
+    it 'remembers both blocks' do
+      Fabricate.sequence(:shapes) do |i|
+        %w[square circle rectangle][i % 3]
+      end
+      Fabricate.sequence(:colors) do |i|
+        %w[red green blue][i % 3]
+      end
+      Fabricate.sequence(:shapes).should == 'circle'
+      Fabricate.sequence(:colors).should == 'green'
+    end
   end
-
 end

data/spec/spec_helper.rb

@@ -7,6 +7,6 @@ require 'ffaker'
 Dir[File.expand_path(File.join(File.dirname(__FILE__),'support','**','*.rb'))].each {|f| require f}
 
 RSpec.configure do |config|
-  config.before(:suite) { TestMigration.up }
+  config.before(:all) { TestMigration.up }
   config.before(:all) { clear_mongodb }
 end

metadata

@@ -2,7 +2,7 @@
 name: fabrication
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 1.1.0
+  version: 1.2.0
 platform: ruby
 authors: 
 - Paul Elliott
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-08-26 00:00:00 Z
+date: 2011-09-26 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: activerecord
@@ -145,6 +145,7 @@ extra_rdoc_files: []
 files: 
 - lib/fabrication/attribute.rb
 - lib/fabrication/config.rb
+- lib/fabrication/cucumber.rb
 - lib/fabrication/errors/duplicate_fabricator_error.rb
 - lib/fabrication/errors/unfabricatable_error.rb
 - lib/fabrication/errors/unknown_fabricator_error.rb
@@ -164,6 +165,7 @@ files:
 - lib/rails/generators/fabrication/model/templates/fabricator.rb
 - spec/fabrication/attribute_spec.rb
 - spec/fabrication/config_spec.rb
+- spec/fabrication/cucumber_spec.rb
 - spec/fabrication/fabricator_spec.rb
 - spec/fabrication/generator/active_record_spec.rb
 - spec/fabrication/generator/base_spec.rb