Fingertips-fakutori-san 0.1.0

data/README.rdoc

@@ -0,0 +1,9 @@
+= FakutoriSan
+
+As its description, FakutoriSan aims to be a lean model factory. As it uses
+vanilla Ruby to define the factories, you can use class inheritance and all
+other standard Ruby practices.
+
+TODO:
+* Write documentation
+* Add examples

data/Rakefile

@@ -0,0 +1,42 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+desc 'Test the fakutori-san plugin.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+desc 'Generate documentation for the fakutori-san plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Fakutori-san'
+  rdoc.options << '--line-numbers' << '--inline-source' << '--charset=utf8'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |s|
+    s.name     = "fakutori-san"
+    s.homepage = "http://github.com/Fingertips/fakutori-san"
+    s.email    = "eloy.de.enige@gmail.com"
+    s.authors  = ["Eloy Duran"]
+    s.summary  = s.description = "FakutoriSan is a lean model factory plugin which uses vanilla Ruby to define the factories, allowing you to optimally use inheritance etc."
+  end
+rescue LoadError
+end
+ 
+begin
+  require 'jewelry_portfolio/tasks'
+  JewelryPortfolio::Tasks.new do |p|
+    p.account = 'Fingertips'
+  end
+rescue LoadError
+end

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:major: 0
+:minor: 1
+:patch: 0

data/lib/fakutori_san.rb

@@ -0,0 +1,167 @@
+# = FakutoriSan
+#
+# As its description, FakutoriSan aims to be a lean model factory. As it uses
+# vanilla Ruby to define the factories, you can use class inheritance and all
+# other standard Ruby practices.
+module FakutoriSan
+  class FakutoriMissing < NameError; end
+  
+  # Returns a hash of the available <tt>model => factory</tt> pairs.
+  def self.factories
+    @factories ||= {}
+  end
+  
+  module FakutoriExt
+    def associate_to(model, options = nil)
+      @__factory__.associate(self, model, options)
+      self
+    end
+    
+    def apply_scene(name, options = {})
+      @__factory__.scene(name, self, options)
+    end
+  end
+  
+  class Collection < Array
+    include FakutoriExt
+    
+    def initialize(factory, times)
+      @__factory__ = factory
+      super(times)
+    end
+    
+    def factory
+      @__factory__
+    end
+  end
+  
+  class Fakutori
+    class << self
+      def inherited(factory_klass)
+        model_klass = Object.const_get(factory_klass.name.gsub(/^FakutoriSan::|Fakutori$/, ''))
+        factory_klass.for_model model_klass
+      rescue NameError
+      end
+      
+      def for_model(model)
+        FakutoriSan.factories[model] = new(model)
+      end
+    end
+    
+    attr_reader :model
+    
+    def initialize(model)
+      @model = model
+    end
+    
+    def plan_one(*type_and_or_attributes)
+      attributes = type_and_or_attributes.extract_options!
+      type = type_and_or_attributes.pop || :valid
+      m = "#{type}_attrs"
+      
+      if respond_to?(m)
+        plan = method(m).arity.zero? ? send(m) : send(m, attributes)
+        plan.merge(attributes)
+      else
+        raise NoMethodError, "#{self.class.name} has no attributes method for type `#{type}'"
+      end
+    end
+    
+    def plan(*times_and_or_type_and_or_attributes)
+      multiple_times :plan, times_and_or_type_and_or_attributes
+    end
+    
+    def build_one(*type_and_or_attributes)
+      make_chainable(@model.new(plan_one(*type_and_or_attributes)))
+    end
+    
+    def build(*times_and_or_type_and_or_attributes)
+      multiple_times :build, times_and_or_type_and_or_attributes
+    end
+    
+    def create_one(*type_and_or_attributes_and_or_validate)
+      args = type_and_or_attributes_and_or_validate
+      
+      validate = args.pop if [true, false].include?(args.last)
+      instance = build_one(*args)
+      validate ? instance.save! : instance.save(false)
+      instance
+    end
+    
+    def create_one!(*type_and_or_attributes)
+      type_and_or_attributes << true
+      create_one(*type_and_or_attributes)
+    end
+    
+    def create(*times_and_or_type_and_or_attributes)
+      multiple_times :create, times_and_or_type_and_or_attributes
+    end
+    
+    def create!(*times_and_or_type_and_or_attributes)
+      times_and_or_type_and_or_attributes << true
+      create(*times_and_or_type_and_or_attributes)
+    end
+    
+    def associate(record_or_collection, to_model, options = nil)
+      if builder = association_builder_for(to_model)
+        [*record_or_collection].each do |record|
+          send(*[builder, record, to_model, options].compact)
+        end
+      else
+        raise NoMethodError, "#{self.class.name} has no association builder method for model `#{to_model.inspect}'."
+      end
+      
+      record_or_collection
+    end
+    
+    def scene(name, record_or_collection, options = {})
+      method = "#{name}_scene"
+      unless respond_to?(method)
+        raise NoMethodError, "#{self.class.name} has no scene method for scene `#{name.inspect}'"
+      end
+      
+      if record_or_collection.is_a?(Array)
+        record_or_collection.each_with_index do |record, index|
+          options[:index] = index
+          send(method, record, options)
+        end
+      else
+        send(method, record_or_collection, options)
+      end
+      
+      record_or_collection
+    end
+    
+    private
+    
+    def make_chainable(instance)
+      instance.extend(FakutoriExt)
+      instance.instance_variable_set(:@__factory__, self)
+      instance
+    end
+    
+    def multiple_times(type, args)
+      m = "#{type}_one"
+      
+      if args.first.is_a?(Numeric)
+        Collection.new(self, args.shift) { send(m, *args) }
+      else
+        send(m, *args)
+      end
+    end
+    
+    def association_builder_for(model)
+      klass = model.is_a?(Class) ? model : model.class
+      name = "associate_to_#{klass.name.underscore.gsub('/', '_')}".to_sym
+      name if respond_to?(name)
+    end
+  end
+end
+
+module Kernel
+  def Fakutori(model)
+    FakutoriSan.factories[model] || raise(FakutoriSan::FakutoriMissing, "No factory defined for model `#{model}'")
+  end
+  
+  private :Fakutori
+end

data/rails/init.rb

@@ -0,0 +1 @@
+require 'fakutori_san'

data/test/fakutori_san_test.rb

@@ -0,0 +1,354 @@
+require File.expand_path('../test_helper', __FILE__)
+
+class Member < ActiveRecord::Base
+  validates_presence_of :name
+end
+
+class Article < ActiveRecord::Base
+end
+
+class Unrelated
+end
+
+module Namespaced
+  class Article
+  end
+end
+
+module FakutoriSan
+  class MemberFakutori < Fakutori
+    def valid_attrs
+      { 'name' => 'Eloy', 'email' => 'eloy@example.com', 'password' => 'secret' }
+    end
+    
+    def minimal_attrs
+      { 'name' => 'Eloy' }
+    end
+    
+    def invalid_attrs
+      {}
+    end
+    
+    def with_arg_attrs(arg)
+      { 'arg' => arg }
+    end
+    
+    def with_name_scene(member, options)
+      member.update_attribute :name, "#{options[:name]}#{options[:index]}"
+    end
+    
+    def associate_to_article(member, article, options)
+    end
+    
+    def associate_to_namespaced_article(member, article, options)
+    end
+  end
+  
+  class FooFakutori < Fakutori
+    for_model Article
+  end
+end
+
+module SharedSpecsHelper
+  def define_shared_specs_for(type)
+    it "should call ##{type}_one multiple times and return an array of the resulting attribute hashes" do
+      attributes = { 'name' => 'Eloy' }
+      
+      @factory.expects("#{type}_one").with(attributes).times(2).returns({})
+      @factory.send(type, 2, attributes).should == [{}, {}]
+      
+      @factory.expects("#{type}_one").with(:minimal, attributes).times(2).returns({})
+      @factory.send(type, 2, :minimal, attributes).should == [{}, {}]
+    end
+    
+    it "should not call ##{type}_one multiple times if no `times' argument is given" do
+      attributes = { 'name' => 'Eloy' }
+      
+      @factory.expects("#{type}_one").with(attributes).times(1).returns({})
+      @factory.send(type, attributes).should == {}
+      
+      @factory.expects("#{type}_one").with(:minimal, attributes).times(1).returns({})
+      @factory.send(type, :minimal, attributes).should == {}
+    end
+    
+    it "should return a FakutoriSan::Collection instance when a collection is created" do
+      collection = @factory.send(type, 2)
+      collection.should.be.instance_of FakutoriSan::Collection
+      collection.factory.should.be @factory
+    end
+    
+    unless type == :plan
+      it "should extend each instance returned by FakutoriSan with the FakutoriSan::FakutoriExt module" do
+        instance = @factory.create_one
+        FakutoriSan::FakutoriExt.instance_methods.each do |method|
+          instance.should.respond_to method
+        end
+      end
+    end
+  end
+end
+Test::Unit::TestCase.send(:extend, SharedSpecsHelper)
+
+describe "FakutoriSan::Fakutori, concerning setup" do
+  it "should automatically find the model class based on the factory class's name and initialize an instance the factory subclass" do
+    factory = FakutoriSan.factories[Member]
+    factory.should.be.instance_of FakutoriSan::MemberFakutori
+    factory.model.should.be Member
+  end
+  
+  it "should allow a user to explicitly define the model class when automatically finding the right class fails" do
+    factory = FakutoriSan.factories[Article]
+    factory.should.be.instance_of FakutoriSan::FooFakutori
+    factory.model.should.be Article
+  end
+end
+
+describe "The top level Fakutori method" do
+  it "should return the factory belonging to the given model" do
+    Fakutori(Member).should.be FakutoriSan.factories[Member]
+    Fakutori(Article).should.be FakutoriSan.factories[Article]
+  end
+  
+  it "should raise a FakutoriSan::FakutoriMissing exception if no factory can be found" do
+    lambda {
+      Fakutori(Unrelated)
+    }.should.raise FakutoriSan::FakutoriMissing
+  end
+end
+
+describe "FakutoriSan::Fakutori, concerning `planning'" do
+  before do
+    @factory = Fakutori(Member)
+  end
+  
+  define_shared_specs_for :plan
+  
+  it "should return a hash of attributes" do
+    @factory.plan_one.should == { 'name' => 'Eloy', 'email' => 'eloy@example.com', 'password' => 'secret' }
+  end
+  
+  it "should merge the given attributes onto the resulting attributes hash" do
+    @factory.plan_one('name' => 'Alloy', 'password' => 'supersecret').should ==
+      { 'name' => 'Alloy', 'email' => 'eloy@example.com', 'password' => 'supersecret' }
+  end
+  
+  it "should pass the attributes hash to the `plan' method" do
+    @factory.plan_one(:with_arg, 'name' => 'Eloy').should ==
+      { 'name' => 'Eloy', 'arg' => { 'name' => 'Eloy' } }
+  end
+  
+  it "should take an optional first plan `type', which invokes the method by the same name" do
+    @factory.plan_one(:minimal).should == { 'name' => 'Eloy' }
+    @factory.plan_one(:minimal, 'email' => 'eloy@example.com').should == { 'name' => 'Eloy', 'email' => 'eloy@example.com' }
+  end
+  
+  it "should raise a NoMethodError if given a attributes type for which no method exists" do
+    lambda { @factory.plan_one(:unexisting) }.should.raise NoMethodError
+  end
+end
+
+describe "FakutoriSan::Fakutori, concerning `building'" do
+  before do
+    @factory = Fakutori(Member)
+  end
+  
+  define_shared_specs_for :build
+  
+  it "should build one instance with the default plan" do
+    instance = @factory.build_one
+    instance.should.be.new_record
+    instance.attributes.should == @factory.plan_one
+  end
+  
+  it "should take an optional first plan `type', which invokes the method by the same name" do
+    instance = @factory.build_one(:minimal)
+    instance.should.be.new_record
+    instance.attributes.except('password', 'email').should == @factory.plan_one(:minimal)
+    
+    instance = @factory.build_one(:minimal, 'email' => 'eloy@example.com')
+    instance.should.be.new_record
+    instance.attributes.except('password').should == @factory.plan_one(:minimal, 'email' => 'eloy@example.com')
+  end
+end
+
+describe "FakutoriSan::Fakutori, concerning `creating'" do
+  before do
+    @factory = Fakutori(Member)
+  end
+  
+  define_shared_specs_for :create
+  
+  it "should create one instance with the default plan" do
+    instance = @factory.create_one
+    instance.should.not.be.new_record
+    instance.attributes.except('id').should == @factory.plan_one
+  end
+  
+  it "should not perform validations by default" do
+    instance = @factory.create_one(:invalid)
+    instance.should.not.be.new_record
+    instance.should.not.be.valid
+  end
+  
+  it "should take an optional first plan `type', which invokes the method by the same name" do
+    instance = @factory.create_one(:minimal)
+    instance.should.not.be.new_record
+    instance.attributes.except('id', 'password', 'email').should == @factory.plan_one(:minimal)
+    
+    instance = @factory.create_one(:minimal, 'email' => 'eloy@example.com')
+    instance.should.not.be.new_record
+    instance.attributes.except('id', 'password').should == @factory.plan_one(:minimal, 'email' => 'eloy@example.com')
+  end
+  
+  it "should perform validations and raise an exception if created with #create_one!" do
+    lambda {
+      @factory.create_one!(:invalid)
+    }.should.raise ActiveRecord::RecordInvalid
+    
+    lambda {
+      instance = @factory.create_one!(:minimal, 'password' => '12345')
+      instance.attributes.except('id', 'email').should == @factory.plan_one(:minimal, 'password' => '12345')
+    }.should.not.raise ActiveRecord::RecordInvalid
+  end
+  
+  it "should call #create_one multiple times and perform validations, and return an array of the resulting record instances" do
+    attributes = { 'name' => 'Eloy' }
+    
+    @factory.expects(:create_one).with(attributes, true).times(2).returns({})
+    @factory.create!(2, attributes)
+    
+    @factory.expects(:create_one).with(:minimal, attributes, true).times(2).returns({})
+    @factory.create!(2, :minimal, attributes)
+  end
+end
+
+describe "FakutoriSan::Fakutori, concerning associating records" do
+  before do
+    @factory = Fakutori(Member)
+    @record = @factory.create_one
+  end
+  
+  it "should return the association builder method if it exists for the given model" do
+    @factory.send(:association_builder_for, Article).should == :associate_to_article
+    @factory.send(:association_builder_for, Article.new).should == :associate_to_article
+    
+    @factory.send(:association_builder_for, Namespaced::Article).should == :associate_to_namespaced_article
+    @factory.send(:association_builder_for, Namespaced::Article.new).should == :associate_to_namespaced_article
+  end
+  
+  it "should return nil if no association builder method can be found for the given model" do
+    @factory.send(:association_builder_for, Unrelated).should == nil
+    @factory.send(:association_builder_for, Unrelated.new).should == nil
+  end
+  
+  it "should call a builder method if it exists for the given model class" do
+    options = {}
+    @factory.expects(:associate_to_article).with(@record, Article, options)
+    @factory.associate(@record, Article, options).should.be @record
+  end
+  
+  it "should call a builder method for each member of a collection" do
+    options = {}
+    collection = @factory.create(2)
+    
+    @factory.expects(:associate_to_article).with(collection.first, Article, options)
+    @factory.expects(:associate_to_article).with(collection.last, Article, options)
+    @factory.associate(collection, Article, options).should.be collection
+  end
+  
+  it "should raise an NoMethodError if an association builder method doesn't exist for a given model" do
+    lambda {
+      @factory.associate(@record, Unrelated, {})
+    }.should.raise NoMethodError
+  end
+  
+  it "should only forward the options hash if it's given by the user" do
+    @factory.expects(:associate_to_article).with(@record, Article)
+    @factory.associate(@record, Article)
+  end
+end
+
+describe "FakutoriSan::Collection, concerning associating records" do
+  before do
+    @factory = Fakutori(Member)
+    @collection = @factory.create!(2)
+  end
+  
+  it "should call #associate on each member and forward the given model and arguments" do
+    options = { 'name' => 'Eloy' }
+    @factory.expects(:associate).with(@collection, Article, options)
+    @collection.associate_to(Article, options)
+  end
+  
+  it "should return itself after associating so the user can chain calls" do
+    @collection.associate_to(Article, {}).should.be @collection
+  end
+  
+  it "should forward the options as `nil' by default" do
+    @factory.expects(:associate).with(@collection, Article, nil)
+    @collection.associate_to(Article)
+  end
+end
+
+describe "FakutoriSan::Fakutori, concerning `scenes'" do
+  before do
+    @factory = Fakutori(Member)
+  end
+  
+  it "should invoke a scene method if it exists and return self" do
+    instance = @factory.create_one
+    @factory.scene(:with_name, instance, :name => 'Alloy').should == instance
+    instance.name.should == 'Alloy'
+  end
+  
+  it "should invoke a scene method for each record in a collection, assign the index to the options, and return self" do
+    collection = @factory.create!(2)
+    @factory.scene(:with_name, collection, :name => 'Alloy').should == collection
+    collection.each_with_index do |record, index|
+      record.reload.name.should == "Alloy#{index}"
+    end
+  end
+  
+  it "should raise a NoMethodError if a requested scene does not exist" do
+    lambda {
+      @factory.scene(:does_not_exist, @factory.build_one)
+    }.should.raise NoMethodError
+  end
+end
+
+describe "FakutoriSan::Collection, concerning `scenes'" do
+  before do
+    @factory = Fakutori(Member)
+    @collection = @factory.create!(2)
+  end
+  
+  it "should call Fakutori#scene with the given scene name, itself, and options" do
+    @collection.apply_scene(:with_name, :name => 'Alloy')
+    @collection.each do |record|
+      record.reload.name.should.match /^Alloy/
+    end
+  end
+end
+
+describe "FakutoriSan::FakutoriExt" do
+  before do
+    @factory = Fakutori(Member)
+  end
+  
+  it "should call Fakutori#associate with the record and options given and return itself" do
+    instance = @factory.create_one
+    
+    @factory.expects(:associate).with(instance, Article, nil)
+    instance.associate_to(Article).should.be instance
+    
+    options = {}
+    @factory.expects(:associate).with(instance, Article, options)
+    instance.associate_to(Article, options).should.be instance
+  end
+  
+  it "should call Fakutori#scene with the record and options given" do
+    instance = @factory.create_one
+    instance.apply_scene(:with_name).reload.name.should == ''
+    instance.apply_scene(:with_name, :name => 'Alloy').reload.name.should == 'Alloy'
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,47 @@
+TEST_ROOT_DIR = File.expand_path('..', __FILE__)
+require 'test/unit'
+
+frameworks = %w(activesupport activerecord actionpack)
+
+rails = [
+  File.expand_path('../../../rails', TEST_ROOT_DIR),
+  File.expand_path('../../rails', TEST_ROOT_DIR)
+].detect do |possible_rails|
+  begin
+    entries = Dir.entries(possible_rails)
+    frameworks.all? { |framework| entries.include?(framework) }
+  rescue Errno::ENOENT
+    false
+  end
+end
+
+frameworks.each { |framework| $:.unshift(File.join(rails, framework, 'lib')) }
+$:.unshift File.join(TEST_ROOT_DIR, '/../lib')
+$:.unshift File.join(TEST_ROOT_DIR, '/lib')
+$:.unshift TEST_ROOT_DIR
+
+ENV['RAILS_ENV'] = 'test'
+
+# Rails libs
+frameworks.each { |framework| require framework }
+require File.expand_path('../../rails/init', __FILE__)
+
+# Libraries for testing
+require 'rubygems' rescue LoadError
+require 'test/spec'
+require 'mocha'
+
+# Open a connection for ActiveRecord
+ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :database => ":memory:")
+ActiveRecord::Migration.verbose = false
+
+ActiveRecord::Schema.define(:version => 1) do
+  create_table :members do |t|
+    t.string :name
+    t.string :email
+    t.string :password
+  end
+  
+  create_table :articles do |t|
+  end
+end

metadata

@@ -0,0 +1,61 @@
+--- !ruby/object:Gem::Specification 
+name: Fingertips-fakutori-san
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Eloy Duran
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-08-10 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: FakutoriSan is a lean model factory plugin which uses vanilla Ruby to define the factories, allowing you to optimally use inheritance etc.
+email: eloy.de.enige@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- README.rdoc
+- Rakefile
+- VERSION.yml
+- lib/fakutori_san.rb
+- rails/init.rb
+- test/fakutori_san_test.rb
+- test/test_helper.rb
+has_rdoc: false
+homepage: http://github.com/Fingertips/fakutori-san
+licenses: 
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: FakutoriSan is a lean model factory plugin which uses vanilla Ruby to define the factories, allowing you to optimally use inheritance etc.
+test_files: 
+- test/fakutori_san_test.rb
+- test/test_helper.rb