fabrication 0.6.0 → 0.6.2

data/README.markdown

@@ -118,18 +118,3 @@ To run rake successfully:
 3. Install bundler
 4. Run `bundle install` from the project root
 5. Run `rake` and the test suite should be all green!
-
-
-look into: Object.reflect_on_associations
-
-Fabricator(:atlanta_hub, :from => :hub) do
-  city "Atlanta"
-  state "GA"
-  location [33.755, -84.39]
-  hardwares(:hardware, :as => :headend, :count => 4) do |hub, index|
-    name 'something'
-  end
-end
-
-
-build option cascades down to associations

data/lib/fabrication.rb

@@ -1,8 +1,10 @@
 module Fabrication
 
-  require 'fabrication/errors'
+  autoload :DuplicateFabricatorError, 'fabrication/errors'
+  autoload :UnfabricatableError,      'fabrication/errors'
 
   autoload :Fabricator, 'fabrication/fabricator'
+  autoload :Sequencer,  'fabrication/sequencer'
   autoload :Schematic,  'fabrication/schematic'
   autoload :Support,    'fabrication/support'
 
@@ -14,36 +16,6 @@ module Fabrication
 
   class << self
 
-    def schematic(name, options, &block)
-      raise DuplicateFabricatorError if fabricators.has_key?(name)
-      parent = fabricators[options[:from]]
-      if options[:class_name]
-        class_name = options[:class_name]
-      elsif parent
-        class_name = parent.class_name
-      elsif options[:from]
-        class_name = options[:from]
-      else
-        class_name = name
-      end
-      fabricators[name] = Fabricator.new(class_name, parent, &block)
-    end
-
-    def generate(name, options, overrides, &block)
-      find_definitions if @@fabricators.nil?
-      raise UnknownFabricatorError unless Fabrication::Support.fabricatable?(name)
-      schematic(name, {}) unless fabricators.has_key?(name)
-      fabricators[name].fabricate(options, overrides, &block)
-    end
-
-    def sequence(name, start=0)
-      idx = sequences[name] ||= start
-
-      (block_given? ? yield(idx) : idx).tap do
-        sequences[name] += 1
-      end
-    end
-
     def attributes_for(name, options)
       hash = defined?(HashWithIndifferentAccess) ? HashWithIndifferentAccess.new : {}
       fetch_schematic(name).attributes.inject(hash) do |hash, attribute|
@@ -52,50 +24,15 @@ module Fabrication
       end.merge(options)
     end
 
-    def find_definitions
-      fabricator_file_paths = [
-        File.join('test', 'fabricators'),
-        File.join('spec', 'fabricators')
-      ]
-      fabricator_file_paths.each do |path|
-        if File.exists?("#{path}.rb")
-          require("#{path}.rb") 
-        end
-
-        if File.directory? path
-          Dir[File.join(path, '*.rb')].each do |file|
-            require file
-          end
-        end
-      end
-    end
-
     def clear_definitions
-      fabricators.clear
-      sequences.clear
-    end
-
-    def fabricators
-      @@fabricators ||= {}
-    end
-
-    def sequences
-      @@sequences ||= {}
+      Fabricator.schematics.clear
+      Sequencer.sequences.clear
     end
 
     private
 
-    @@fabricators = nil
-
     def fetch_schematic(name)
-      if fabricator = fabricators[name]
-        fabricator.schematic
-      else
-        # force finding definitions after setting @@fabricators to an empty array
-        Fabrication.send(:class_variable_set, :@@fabricators, nil) if Fabrication.fabricators.empty?
-        build(name)
-        fetch_schematic(name)
-      end
+      Fabricator.schematics[name] || Fabricator.define(name)
     end
 
   end
@@ -103,11 +40,11 @@ module Fabrication
 end
 
 def Fabricator(name, options={}, &block)
-  Fabrication.schematic(name, options, &block)
+  Fabrication::Fabricator.define(name, options, &block)
 end
 
-def Fabricate(name, options={}, &block)
-  Fabrication.generate(name, {:save => true}, options, &block)
+def Fabricate(name, overrides={}, &block)
+  Fabrication::Fabricator.generate(name, {:save => true}, overrides, &block)
 end
 
 class Fabricate
@@ -115,11 +52,11 @@ class Fabricate
   class << self
 
     def build(name, options={}, &block)
-      Fabrication.generate(name, {:save => false}, options, &block)
+      Fabrication::Fabricator.generate(name, {:save => false}, options, &block)
     end
 
     def sequence(name, start=0, &block)
-      Fabrication.sequence(name, start, &block)
+      Fabrication::Sequencer.sequence(name, start, &block)
     end
 
     def attributes_for(name, options={})

data/lib/fabrication/errors.rb

@@ -2,6 +2,6 @@ module Fabrication
 
   class DuplicateFabricatorError < StandardError; end
 
-  class UnknownFabricatorError < StandardError; end
+  class UnfabricatableError < StandardError; end
 
 end

data/lib/fabrication/fabricator.rb

@@ -1,28 +1,48 @@
 class Fabrication::Fabricator
 
-  GENERATORS = [
-    Fabrication::Generator::ActiveRecord,
-    Fabrication::Generator::Mongoid,
-    Fabrication::Generator::Base
-  ]
-
-  attr_accessor :class_name, :schematic
-
-  def initialize(class_name, parent=nil, &block)
-    self.class_name = class_name
-    klass = Fabrication::Support.class_for(class_name)
-    self.schematic = parent ? parent.schematic.clone.merge!(&block) : Fabrication::Schematic.new(&block)
-    self.generator = GENERATORS.detect do |gen|
-      gen.supports?(klass)
-    end.new(klass, schematic)
-  end
+  class << self
 
-  def fabricate(options={}, overrides={}, &block)
-    generator.generate(options, overrides, &block)
-  end
+    def define(name, options={}, &block)
+      raise Fabrication::DuplicateFabricatorError if schematics.include?(name)
+      schematics[name] = schematic_for(name, options, &block)
+    end
+
+    def generate(name, options={}, overrides={}, &block)
+      Fabrication::Support.find_definitions if schematics.empty?
+      (schematics[name] || define(name)).generate(options, overrides, &block)
+    end
+
+    def schematics
+      @@schematics ||= {}
+    end
 
-  private
+    private
 
-  attr_accessor :generator
+    def class_name_for(name, parent, options)
+      if options[:class_name]
+        class_name = options[:class_name]
+      elsif parent
+        class_name = parent.klass.name
+      elsif options[:from]
+        class_name = options[:from]
+      else
+        class_name = name
+      end
+      class_name
+    end
+
+    def schematic_for(name, options, &block)
+      parent = schematics[options[:from]]
+      class_name = class_name_for(name, parent, options)
+      klass = Fabrication::Support.class_for(class_name)
+      raise Fabrication::UnfabricatableError unless klass
+      if parent
+        parent.merge(&block).tap { |s| s.klass = klass }
+      else
+        Fabrication::Schematic.new(klass, &block)
+      end
+    end
+
+  end
 
 end

data/lib/fabrication/generator/base.rb

@@ -6,21 +6,19 @@ class Fabrication::Generator::Base
     self.after_create_block = block if block_given?
   end
 
-  def generate(options={:save => true}, overrides={}, &block)
-    self.instance = klass.new
-    process_attributes(overrides, &block)
+  def generate(options={:save => true}, attributes=[])
+    process_attributes(attributes)
     after_generation(options)
     after_create_block.call(instance) if after_create_block
     instance
   end
 
-  def initialize(klass, schematic=nil)
-    self.klass = klass
-    self.schematic = schematic
+  def initialize(klass)
+    self.instance = klass.new
   end
 
   def method_missing(method_name, *args, &block)
-    assign(method_name.to_s, args.first, &block)
+    assign(method_name, args.first, &block)
   end
 
   protected
@@ -29,11 +27,11 @@ class Fabrication::Generator::Base
 
   private
 
-  attr_accessor :after_create_block, :instance, :klass, :schematic
+  attr_accessor :after_create_block, :instance
 
   def assign(method_name, param)
     value = nil
-    if param.is_a?(Hash) && param[:count] && param[:count] > 1
+    if param.is_a?(Hash) && param.has_key?(:count) && param[:count] > 1
       value = (1..param[:count]).map do |i|
         block_given? ? yield(instance, i) : param
       end
@@ -43,8 +41,8 @@ class Fabrication::Generator::Base
     instance.send("#{method_name.to_s}=", value)
   end
 
-  def process_attributes(options, &block)
-    schematic.merge(options, &block).attributes.each do |attribute|
+  def process_attributes(attributes)
+    attributes.each do |attribute|
       if attribute.name == :after_create
         after_create(&attribute.value)
       else

data/lib/fabrication/generator/mongoid.rb

@@ -1,11 +1,11 @@
 class Fabrication::Generator::Mongoid < Fabrication::Generator::Base
 
-  def after_generation(options)
-    instance.save if options[:save]
-  end
-
   def self.supports?(klass)
     defined?(Mongoid) && klass.ancestors.include?(Mongoid::Document)
   end
 
+  def after_generation(options)
+    instance.save if options[:save]
+  end
+
 end

data/lib/fabrication/schematic.rb

@@ -1,6 +1,15 @@
 class Fabrication::Schematic
 
-  def initialize(&block)
+  GENERATORS = [
+    Fabrication::Generator::ActiveRecord,
+    Fabrication::Generator::Mongoid,
+    Fabrication::Generator::Base
+  ]
+
+  attr_accessor :generator, :klass
+  def initialize(klass, &block)
+    self.klass = klass
+    self.generator = GENERATORS.detect { |gen| gen.supports?(klass) }
     instance_eval(&block) if block_given?
   end
 
@@ -8,16 +17,26 @@ class Fabrication::Schematic
     attributes.select { |a| a.name == name }.first
   end
 
+  attr_writer :attributes
+  def attributes
+    @attributes ||= []
+  end
+
+  def generate(options={}, overrides={}, &block)
+    attributes = merge(overrides, &block).attributes
+    generator.new(klass).generate(options, attributes)
+  end
+
   def initialize_copy(original)
     self.attributes = original.attributes.map do |a|
       Attribute.new(a.name, a.params, a.value)
     end
   end
 
-  def merge(options, &block)
+  def merge(overrides={}, &block)
     clone.tap do |schematic|
       schematic.instance_eval(&block) if block_given?
-      options.each do |name, value|
+      overrides.each do |name, value|
         if attribute = schematic.attribute(name)
           attribute.params = nil
           attribute.value = value
@@ -28,11 +47,6 @@ class Fabrication::Schematic
     end
   end
 
-  def merge!(&block)
-    instance_eval(&block)
-    self
-  end
-
   def method_missing(method_name, *args, &block)
     method_name = parse_method_name(method_name, args)
     if (attr = attribute(method_name))
@@ -71,9 +85,4 @@ class Fabrication::Schematic
     end
   end
 
-  attr_writer :attributes
-  def attributes
-    @attributes ||= []
-  end
-
 end

data/lib/fabrication/sequencer.rb

@@ -0,0 +1,19 @@
+class Fabrication::Sequencer
+
+  class << self
+
+    def sequence(name, start=0)
+      idx = sequences[name] ||= start
+
+      (block_given? ? yield(idx) : idx).tap do
+        sequences[name] += 1
+      end
+    end
+
+    def sequences
+      @@sequences ||= {}
+    end
+
+  end
+
+end

data/lib/fabrication/support.rb

@@ -3,7 +3,7 @@ class Fabrication::Support
   class << self
 
     def fabricatable?(name)
-      Fabrication.fabricators.has_key?(name) || class_for(name)
+      Fabrication::Fabricator.schematics.include?(name) || class_for(name)
     end
 
     def class_for(class_or_to_s)
@@ -22,6 +22,18 @@ class Fabrication::Support
       name.to_s.gsub(/\/(.?)/){"::#{$1.upcase}"}.gsub(/(?:^|_)(.)/){$1.upcase}
     end
 
+    def find_definitions
+      ['test', 'spec'].map do |folder|
+        path = File.expand_path(File.join(folder, 'fabricators'))
+
+        require("#{path}.rb") if File.exists?("#{path}.rb")
+
+        File.directory? path and Dir[File.join(path, '*.rb')].each do |file|
+          require file
+        end
+      end
+    end
+
   end
 
 end

data/lib/fabrication/version.rb

@@ -1,3 +1,3 @@
 module Fabrication
-  VERSION = '0.6.0'
+  VERSION = '0.6.2'
 end

data/spec/fabrication_spec.rb

@@ -4,30 +4,16 @@ describe Fabrication do
 
   context 'static fields' do
 
-    let(:person) do
-      Fabricate(:person, :last_name => 'Awesome')
-    end
-
-    before(:all) do
-      Fabricator(:person) do
-        first_name 'Joe'
-        last_name 'Schmoe'
-        age 78
-      end
-    end
+    let(:person) { Fabricate(:person, :last_name => 'Awesome') }
 
     it 'has the default first name' do
-      person.first_name.should == 'Joe'
+      person.first_name.should == 'John'
     end
 
     it 'has an overridden last name' do
       person.last_name.should == 'Awesome'
     end
 
-    it 'has the default age' do
-      person.age.should == 78
-    end
-
     it 'generates a fresh object every time' do
       Fabricate(:person).should_not == person
     end
@@ -36,22 +22,7 @@ describe Fabrication do
 
   context 'block generated fields' do
 
-    let(:person) do
-      Fabricate(:person)
-    end
-
-    before(:all) do
-      Fabricator(:person) do
-        first_name { Faker::Name.first_name }
-        last_name { Faker::Name.last_name }
-        age { rand(100) }
-        shoes(:count => 10) { |person, i| "shoe #{i}" }
-      end
-    end
-
-    it 'has a first name' do
-      person.first_name.should be
-    end
+    let(:person) { Fabricate(:person) }
 
     it 'has a last name' do
       person.last_name.should be
@@ -69,16 +40,13 @@ describe Fabrication do
 
   context 'with the generation parameter' do
 
-    before(:all) do
-      Fabricator(:person) do
+    let(:person) do
+      Fabricate(:person) do
         first_name "Paul"
         last_name { |person| "#{person.first_name}#{person.age}" }
-        age 60
       end
     end
 
-    let(:person) { Fabricate(:person) }
-
     it 'evaluates the fields in order of declaration' do
       person.last_name.should == "Paul"
     end
@@ -90,14 +58,6 @@ describe Fabrication do
     let(:person1) { Fabricate(:person, :first_name => 'Jane') }
     let(:person2) { Fabricate(:person, :first_name => 'John') }
 
-    before(:all) do
-      Fabricator(:person) do
-        first_name { Faker::Name.first_name }
-        last_name { Faker::Name.last_name }
-        age { rand(100) }
-      end
-    end
-
     it 'person1 is named Jane' do
       person1.first_name.should == 'Jane'
     end
@@ -130,6 +90,9 @@ describe Fabrication do
 
   context 'with an active record object' do
 
+    before { TestMigration.up }
+    after  { TestMigration.down }
+
     before(:all) do
       Fabricator(:company) do
         name { Faker::Company.name }
@@ -140,15 +103,8 @@ describe Fabrication do
       Fabricator(:other_company, :from => :company) do
         divisions(:count => 2) { Fabricate(:division) }
       end
-
-      Fabricator(:division) do
-        name "Awesome Division"
-      end
     end
 
-    before { TestMigration.up }
-    after { TestMigration.down }
-
     let(:company) { Fabricate(:company, :name => "Hashrocket") }
 
     it 'generates field blocks immediately' do
@@ -176,19 +132,6 @@ describe Fabrication do
 
   context 'with a mongoid document' do
 
-    before(:all) do
-      Fabricator(:author) do
-        name "George Orwell"
-        books(:count => 4) do |author, i|
-          Fabricate(:book, :title => "book title #{i}", :author => author)
-        end
-      end
-
-      Fabricator(:book) do
-        title "1984"
-      end
-    end
-
     let(:author) { Fabricate(:author) }
 
     it "sets the author name" do
@@ -206,20 +149,8 @@ describe Fabrication do
 
       let(:ernie) { Fabricate(:hemingway) }
 
-      before(:all) do
-        Fabricator(:book)
-        Fabricator(:author) do
-          name 'George Orwell'
-          books { |author| [Fabricate(:book, :title => '1984', :author => author)] }
-        end
-
-        Fabricator(:hemingway, :from => :author) do
-          name 'Ernest Hemingway'
-        end
-      end
-
       it 'has the values from the parent' do
-        ernie.books.map(&:title).should == ['1984']
+        ernie.books.count.should == 4
       end
 
       it 'overrides specified values from the parent' do
@@ -230,20 +161,14 @@ describe Fabrication do
 
     context 'and a class name as a parent' do
 
-      before(:all) do
-        Fabricator(:hemingway, :from => :author) do
-          name 'Ernest Hemingway'
-        end
-      end
+      let(:greyhound) { Fabricate(:greyhound) }
 
-      let(:ernie) { Fabricate(:hemingway) }
-
-      it 'has the name defined' do
-        ernie.name.should == 'Ernest Hemingway'
+      it 'has the breed defined' do
+        greyhound.breed.should == 'greyhound'
       end
 
-      it 'not have any books' do
-        ernie.books.should == []
+      it 'does not have a name' do
+        greyhound.name.should be_nil
       end
 
     end
@@ -253,12 +178,15 @@ describe Fabrication do
   describe '.clear_definitions' do
 
     before(:all) do
-      Fabricator(:author) {}
       Fabrication.clear_definitions
     end
 
+    after(:all) do
+      Fabrication::Support.find_definitions
+    end
+
     it 'should not generate authors' do
-      Fabrication.fabricators.has_key?(:author).should be_false
+      Fabrication::Fabricator.schematics.has_key?(:author).should be_false
     end
 
   end
@@ -278,17 +206,20 @@ describe Fabrication do
   context 'when generating from a non-existant fabricator' do
 
     it 'throws an error' do
-      lambda { Fabricate(:your_mom) }.should raise_error(Fabrication::UnknownFabricatorError)
+      lambda { Fabricate(:your_mom) }.should raise_error(Fabrication::UnfabricatableError)
     end
 
   end
 
   context 'defining a fabricator without a block' do
 
-    before(:all) { Fabricator(:author) }
+    before(:all) do
+      class Widget; end
+      Fabricator(:widget)
+    end
 
     it 'works fine' do
-      Fabricate(:author).should be
+      Fabricate(:widget).should be
     end
 
   end
@@ -298,10 +229,17 @@ describe Fabrication do
     let(:author) { Fabricator(:author) }
     let(:book) { Fabricator(:book) }
 
-    before(:all) { author; book }
+    before(:all) do
+      Fabrication.clear_definitions
+      author; book
+    end
+
+    after(:all) do
+      Fabrication::Support.find_definitions
+    end
 
     it "returns the two fabricators" do
-      Fabrication.fabricators.should == {:author => author, :book => book}
+      Fabrication::Fabricator.schematics.should == {:author => author, :book => book}
     end
 
   end
@@ -335,21 +273,16 @@ describe Fabrication do
 
   describe "Fabricate.attributes_for" do
 
-    before(:all) do
-      Fabricator(:person) do
-        first_name "Paul"
-        last_name { "Elliott" }
-      end
+    let(:person) do
+      Fabricate.attributes_for(:person, :first_name => "John", :last_name => "Smith")
     end
 
-    let(:person) { Fabricate.attributes_for(:person) }
-
     it 'has the first name as a parameter' do
-      person['first_name'].should == "Paul"
+      person['first_name'].should == "John"
     end
 
     it 'has the last name as a parameter' do
-      person[:last_name].should == "Elliott"
+      person[:last_name].should == "Smith"
     end
 
   end