fabrication 0.0.1

data/lib/fabrication.rb

@@ -0,0 +1,36 @@
+module Fabrication
+
+  autoload :Fabricator, 'fabrication/fabricator'
+
+  module Generator
+    autoload :ActiveRecord, 'fabrication/generator/active_record'
+    autoload :Base,         'fabrication/generator/base'
+  end
+
+  class << self
+
+    def schematic(name, &block)
+      fabricators[name] = Fabricator.new(name, &block)
+    end
+
+    def generate(name, options)
+      fabricators[name].fabricate(options)
+    end
+
+    private
+
+    def fabricators
+      @@fabricators ||= {}
+    end
+
+  end
+
+end
+
+def Fabricator(name, &block)
+  Fabrication.schematic(name, &block)
+end
+
+def Fabricate(name, options={})
+  Fabrication.generate(name, options)
+end

data/lib/fabrication/fabricator.rb

@@ -0,0 +1,33 @@
+class Fabrication::Fabricator
+
+  def initialize(class_name, &block)
+    klass = class_for(class_name)
+    if klass.ancestors.include?(ActiveRecord::Base)
+      @fabricator = Fabrication::Generator::ActiveRecord.new(klass, &block)
+    else
+      @fabricator = Fabrication::Generator::Base.new(klass, &block)
+    end
+  end
+
+  def fabricate(options={})
+    @fabricator.generate(options)
+  end
+
+  #Stolen directly from factory_girl. Thanks thoughtbot!
+  def class_for(class_or_to_s)
+    if class_or_to_s.respond_to?(:to_sym)
+      class_name = variable_name_to_class_name(class_or_to_s)
+      class_name.split('::').inject(Object) do |object, string|
+        object.const_get(string)
+      end
+    else
+      class_or_to_s
+    end
+  end
+
+  #Stolen directly from factory_girl. Thanks thoughtbot!
+  def variable_name_to_class_name(name)
+    name.to_s.gsub(/\/(.?)/){"::#{$1.upcase}"}.gsub(/(?:^|_)(.)/){$1.upcase}
+  end
+
+end

data/lib/fabrication/generator/active_record.rb

@@ -0,0 +1,42 @@
+class Fabrication::Generator::ActiveRecord < Fabrication::Generator::Base
+
+  def generate(options)
+    @options = options
+    @instance = super
+    @instance.save
+    @instance
+  end
+
+  def method_missing(method_name, *args, &block)
+    method_name = method_name.to_s
+    unless @options.include?(method_name.to_sym)
+      if block_given?
+        unless @instance.class.columns.map(&:name).include?(method_name)
+          # copy the original getter
+          @instance.instance_variable_set("@__#{method_name}_original", @instance.method(method_name).clone)
+
+          # store the block for lazy generation
+          @instance.instance_variable_set("@__#{method_name}_block", block)
+
+          # redefine the getter
+          @instance.instance_eval %<
+            def #{method_name}
+              original_value = @__#{method_name}_original.call
+              if @__#{method_name}_block.present?
+                original_value = #{method_name}= @__#{method_name}_block.call(self)
+                @__#{method_name}_block = nil
+                @__#{method_name}_original.call
+              end
+              original_value
+            end
+          >
+        else
+          assign(@instance, method_name, yield)
+        end
+      else
+        assign(@instance, method_name, args.first)
+      end
+    end
+  end
+
+end

data/lib/fabrication/generator/base.rb

@@ -0,0 +1,25 @@
+class Fabrication::Generator::Base
+
+  def initialize(klass, &block)
+    @klass = klass
+    @block = block
+  end
+
+  def generate(options)
+    @instance = @klass.new
+    instance_eval &@block
+    options.each { |k,v| assign(@instance, k, v) }
+    @instance
+  end
+
+  def method_missing(method_name, *args, &block)
+    assign(@instance, method_name.to_s, block_given? ? yield : args.first)
+  end
+
+  private
+
+  def assign(instance, method_name, value)
+    instance.send("#{method_name.to_s}=", value)
+  end
+
+end

data/lib/fabrication/version.rb

@@ -0,0 +1,3 @@
+module Fabrication
+  VERSION = '0.0.1'
+end

data/spec/block_generated_fields_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+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) }
+      end
+    end
+
+    it 'has a first name' do
+      person.first_name.should be
+    end
+
+    it 'has a last name' do
+      person.last_name.should be
+    end
+
+    it 'has an age' do
+      person.age.should be
+    end
+
+  end
+
+end

data/spec/fabrication_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe Fabrication do
+
+  context 'with an active record object' do
+
+    before(:all) { TestMigration.up }
+    after(:all) { TestMigration.down }
+
+    before do
+      Fabricator(:company) do
+        name { Faker::Company.name }
+      end
+    end
+
+    let(:company) { Fabricate(:company) }
+
+    it 'generates field blocks immediately' do
+      company.name.should be
+    end
+    it 'overrides associations'
+  end
+
+end

data/spec/fabricator_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe Fabrication::Fabricator do
+
+  it 'generates a new object every time' do
+    f = Fabrication::Fabricator.new(:person) { first_name '1' }
+    f.fabricate.should_not == f.fabricate
+  end
+
+  context 'with a plain old ruby object' do
+
+    let(:fabricator) { Fabrication::Fabricator.new(:person) { first_name '1' } }
+
+    it 'fabricates a Person instance' do
+      fabricator.fabricate.instance_of?(Person).should be_true
+    end
+
+    it 'uses the base generator' do
+      fabricator.instance_variable_get(:@fabricator).instance_of?(Fabrication::Generator::Base).should be_true
+    end
+
+  end
+
+  context 'with an activerecord object' do
+
+    before(:all) { TestMigration.up }
+    after(:all) { TestMigration.down }
+
+    let(:fabricator) { Fabrication::Fabricator.new(:company) { name '1' } }
+
+    it 'fabricates a Company instance' do
+      fabricator.fabricate.instance_of?(Company).should be_true
+    end
+
+    it 'uses the activerecord generator' do
+      fabricator.instance_variable_get(:@fabricator).instance_of?(Fabrication::Generator::ActiveRecord).should be_true
+    end
+
+  end
+
+end

data/spec/generator/active_record_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+describe Fabrication::Generator::ActiveRecord do
+
+  before(:all) { TestMigration.up }
+  after(:all) { TestMigration.down }
+
+  context 'active record object' do
+
+    let(:company) do
+      Fabrication::Generator::ActiveRecord.new(Company) do
+        name 'Company Name'
+        divisions { |c| [Fabricate(:division, :company => c)] }
+      end.generate({:name => 'Something'})
+    end
+
+    before(:all) do
+      Fabricator(:division) do
+        name "Division Name"
+      end
+    end
+
+    before { company }
+
+    it 'persists the company upon creation' do
+      Company.find_by_name('Something').should be
+    end
+
+    it 'does not persist the divisions immediately' do
+      Division.count.should == 0
+    end
+
+    context 'upon accessing the divisions association' do
+
+      let(:divisions) { company.divisions }
+
+      it 'generates the divisions' do
+        divisions.length.should == 1
+      end
+
+      it 'persists the divisions' do
+        divisions
+        Division.find_all_by_company_id(company.id).count.should == 1
+      end
+
+      it 'can load the divisions from the database' do
+        company.reload.divisions.length.should == 1
+      end
+
+    end
+
+  end
+
+end

data/spec/generator/base_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe Fabrication::Generator::Base do
+
+  let(:person) do
+    Fabrication::Generator::Base.new(Person) do
+      first_name 'Some'
+      last_name { Faker::Name.last_name }
+      age 40
+    end.generate({:first_name => 'Body'})
+  end
+
+  it 'generates an instance' do
+    person.instance_of?(Person).should be_true
+  end
+
+  it 'generates the first name immediately' do
+    person.instance_variable_get(:@first_name).should == 'Body'
+  end
+
+  it 'generates the last name immediately' do
+    person.instance_variable_get(:@last_name).should be
+  end
+
+  it 'generates the age immediately' do
+    person.instance_variable_get(:@age).should == 40
+  end
+
+end

data/spec/multiple_instance_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe Fabrication do
+
+  context 'multiple instance' 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
+
+    it 'person2 is named John' do
+      person2.first_name.should == 'John'
+    end
+
+    it 'they have different last names' do
+      person1.last_name.should_not == person2.last_name
+    end
+
+  end
+
+end

data/spec/simple_object_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+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
+
+    it 'has the default first name' do
+      person.first_name.should == 'Joe'
+    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
+
+  end
+
+end

data/spec/spec.opts

@@ -0,0 +1,2 @@
+--colour
+--format nested

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+$:.unshift(File.expand_path('../lib', File.dirname(__FILE__)))
+$:.unshift(File.dirname(__FILE__))
+
+require 'rubygems'
+require 'spec'
+require 'spec/autorun'
+require 'fabrication'
+require 'ffaker'
+require 'active_record'

data/spec/support/database_setup.rb

@@ -0,0 +1,34 @@
+# change this if sqlite is unavailable
+dbconfig = {
+  :adapter => 'sqlite3',
+  :database => ':memory:'
+}
+
+ActiveRecord::Base.establish_connection(dbconfig)
+ActiveRecord::Migration.verbose = false
+
+class TestMigration < ActiveRecord::Migration
+  def self.up
+    create_table :companies, :force => true do |t|
+      t.column :name, :string
+    end
+
+    create_table :divisions, :force => true do |t|
+      t.column :name, :string
+      t.references :company
+    end
+  end
+
+  def self.down
+    drop_table :companies
+    drop_table :divisions
+  end
+end
+
+class Company < ActiveRecord::Base
+  has_many :divisions
+end
+
+class Division < ActiveRecord::Base
+  belongs_to :company
+end

data/spec/support/helper_objects.rb

@@ -0,0 +1 @@
+class Person; attr_accessor :age, :first_name, :last_name end

metadata

@@ -0,0 +1,147 @@
+--- !ruby/object:Gem::Specification 
+name: fabrication
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Paul Elliott
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-06-15 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 13
+        segments: 
+        - 1
+        - 2
+        - 9
+        version: 1.2.9
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: ffaker
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 15
+        segments: 
+        - 0
+        - 4
+        - 0
+        version: 0.4.0
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 9
+        segments: 
+        - 2
+        - 3
+        - 5
+        version: 2.3.5
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: sqlite3-ruby
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 27
+        segments: 
+        - 1
+        - 3
+        - 0
+        version: 1.3.0
+  type: :development
+  version_requirements: *id004
+description: Fabrication is an object generation framework that lazily generated attributes as they are used
+email: 
+- paul@hashrocket.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/fabrication/fabricator.rb
+- lib/fabrication/generator/active_record.rb
+- lib/fabrication/generator/base.rb
+- lib/fabrication/version.rb
+- lib/fabrication.rb
+- spec/block_generated_fields_spec.rb
+- spec/fabrication_spec.rb
+- spec/fabricator_spec.rb
+- spec/generator/active_record_spec.rb
+- spec/generator/base_spec.rb
+- spec/multiple_instance_spec.rb
+- spec/simple_object_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+- spec/support/database_setup.rb
+- spec/support/helper_objects.rb
+- README.markdown
+has_rdoc: true
+homepage: http://github.com/paulelliott/fabrication
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Fabrication aims to provide a fast and simple solution for test object generation
+test_files: []
+