machinist 1.0.6 → 2.0.0.beta1

data/lib/machinist/lathe.rb

@@ -0,0 +1,69 @@
+require 'active_support/inflector'
+
+module Machinist
+
+  # When you make an object, the blueprint for that object is instance-evaled
+  # against a Lathe.
+  #
+  # The Lathe implements all the methods that are available to the blueprint,
+  # including method_missing to let the blueprint define attributes.
+  class Lathe
+
+    def initialize(klass, serial_number, attributes = {})
+      @klass               = klass
+      @serial_number       = serial_number
+      @assigned_attributes = {}
+
+      @object              = @klass.new
+      attributes.each {|key, value| assign_attribute(key, value) }
+    end
+
+    # Returns a unique serial number for the object under construction.
+    attr_reader :serial_number
+    alias_method :sn, :serial_number
+
+    # Returns the object under construction.
+    attr_reader :object
+
+    def method_missing(attribute, *args, &block) #:nodoc:
+      unless attribute_assigned?(attribute)
+        assign_attribute(attribute, make_attribute(attribute, args, &block))
+      end
+    end
+
+    # Undef a couple of methods that are common ActiveRecord attributes.
+    # (Both of these are deprecated in Ruby 1.8 anyway.)
+    undef_method :id   if respond_to?(:id)
+    undef_method :type if respond_to?(:type)
+
+  protected
+
+    def make_attribute(attribute, args, &block) #:nodoc:
+      count = args.shift if args.first.is_a?(Fixnum)
+      if count
+        Array.new(count) { make_one_value(attribute, args, &block) }
+      else
+        make_one_value(attribute, args, &block)
+      end
+    end
+
+    def make_one_value(attribute, args) #:nodoc:
+      raise_argument_error(attribute) unless args.empty?
+      yield
+    end
+    
+    def assign_attribute(key, value) #:nodoc:
+      @assigned_attributes[key.to_sym] = value
+      @object.send("#{key}=", value)
+    end
+  
+    def attribute_assigned?(key) #:nodoc:
+      @assigned_attributes.has_key?(key.to_sym)
+    end
+
+    def raise_argument_error(attribute) #:nodoc:
+      raise ArgumentError.new("Invalid arguments to attribute #{attribute} in blueprint") 
+    end
+
+  end
+end

data/lib/machinist/machinable.rb

@@ -0,0 +1,97 @@
+module Machinist
+
+  # Extend classes with this module to define the blueprint and make methods.
+  module Machinable
+    # Define a blueprint with the given name for this class.
+    #
+    # e.g.
+    #   Post.blueprint do
+    #     title { "A Post" }
+    #     body  { "Lorem ipsum..." }
+    #   end
+    #
+    # If you provide the +name+ argument, a named blueprint will be created.
+    # See the +blueprint_name+ argument to the make method.
+    def blueprint(name = :master, &block)
+      @blueprints ||= {}
+      if block_given?
+        parent = (name == :master ? superclass : self) # Where should we look for the parent blueprint?
+        @blueprints[name] = blueprint_class.new(self, :parent => parent, &block)
+      end
+      @blueprints[name]
+    end
+
+    # Construct an object from a blueprint.
+    #
+    # :call-seq:
+    #   make([count], [blueprint_name], [attributes = {}])
+    #
+    # [+count+]
+    #   The number of objects to construct. If +count+ is provided, make
+    #   returns an array of objects rather than a single object.
+    # [+blueprint_name+]
+    #   Construct the object from the named blueprint, rather than the master
+    #   blueprint.
+    # [+attributes+]
+    #   Override the attributes from the blueprint with values from this hash.
+    def make(*args)
+      decode_args_to_make(*args) do |blueprint, attributes|
+        blueprint.make(attributes)
+      end
+    end
+
+    # Construct and save an object from a blueprint, if the class allows saving.
+    #
+    # :call-seq:
+    #   make!([count], [blueprint_name], [attributes = {}])
+    #
+    # A cached object will be returned from the shop if possible. See
+    # Machinist::Shop.
+    #
+    # Arguments are the same as for make.
+    def make!(*args)
+      decode_args_to_make(*args) do |blueprint, attributes|
+        Shop.instance.buy(blueprint, attributes)
+      end
+    end
+
+    # Remove all blueprints defined on this class.
+    def clear_blueprints!
+      @blueprints = {}
+    end
+
+    # Classes that include Machinable can override this method if they want to
+    # use a custom blueprint class when constructing blueprints.
+    #
+    # The default is Machinist::Blueprint.
+    def blueprint_class
+      Machinist::Blueprint
+    end
+
+  private
+
+    # Parses the arguments to make.
+    #
+    # Yields a blueprint and an attributes hash to the block, which should
+    # construct an object from them. The block may be called multiple times to
+    # construct multiple objects.
+    def decode_args_to_make(*args) #:nodoc:
+      shift_arg = lambda {|klass| args.shift if args.first.is_a?(klass) }
+      count      = shift_arg[Fixnum]
+      name       = shift_arg[Symbol] || :master
+      attributes = shift_arg[Hash]   || {}
+      raise ArgumentError.new("Couldn't understand arguments") unless args.empty?
+
+      @blueprints ||= {}
+      blueprint = @blueprints[name]
+      raise NoBlueprintError.new(self, name) unless blueprint
+
+      if count.nil?
+        yield(blueprint, attributes)
+      else
+        Array.new(count) { yield(blueprint, attributes) }
+      end
+    end
+
+  end
+end

data/lib/machinist/shop.rb

@@ -0,0 +1,52 @@
+module Machinist
+
+  # The shop takes care of caching database objects.
+  #
+  # Calling make! on a class requests objects from the shop; you don't
+  # normally access the shop directly.
+  #
+  # Read more about object caching on the
+  # wiki[http://wiki.github.com/notahat/machinist/object-caching].
+  class Shop
+
+    # Return the singleton Shop instance.
+    def self.instance
+      @instance ||= Shop.new
+    end
+
+    def initialize #:nodoc:
+      reset!
+    end
+   
+    # Throw out the entire collection of cached objects.
+    def reset!
+      @warehouse = Warehouse.new
+      restock
+    end
+
+    # Restock the shop with all the cached objects we've got.
+    #
+    # This should be called before each test.
+    def restock
+      @back_room = @warehouse.clone
+    end
+
+    # Buy a (possibly cached) object from the shop.
+    #
+    # This is just like constructing an object by calling Blueprint#make!,
+    # but it will return a previously cached object if one is available.
+    def buy(blueprint, attributes = {})
+      raise BlueprintCantSaveError.new(blueprint) unless blueprint.respond_to?(:make!)
+
+      shelf = @back_room[blueprint, attributes]
+      if shelf.empty?
+        object = blueprint.outside_transaction { blueprint.make!(attributes) }
+        @warehouse[blueprint, attributes] << blueprint.box(object)
+        object
+      else
+        blueprint.unbox(shelf.shift)
+      end
+    end
+
+  end
+end

data/lib/machinist/warehouse.rb

@@ -0,0 +1,36 @@
+module Machinist
+
+  # A Warehouse is a hash supports lists as keys.
+  #
+  # It's used for storing cached objects created by Machinist::Shop.
+  #
+  #     warehouse[1, 2] = "Hello, world!"
+  #     warehouse[1, 2] # => "Hello, world!"
+  class Warehouse < Hash
+
+    # Assign a value for the given list of keys.
+    def []=(*keys)
+      value = keys.pop
+      super(keys, value)
+    end
+
+    # Return the value for the given list of keys.
+    #
+    # If the list of keys doesn't exist in the hash, this assigns a new empty
+    # array to that list of keys.
+    def [](*keys)
+      self[*keys] = [] if !has_key?(keys)
+      super(keys)
+    end
+
+    # Return a new warehouse with the same keys, and dups of all the values.
+    def clone
+      clone = Warehouse.new
+      each_pair do |key, value|
+        clone[*key] = value.dup
+      end
+      clone
+    end
+
+  end
+end

data/spec/active_record_spec.rb

@@ -1,194 +1,125 @@
 require File.dirname(__FILE__) + '/spec_helper'
-require 'machinist/active_record'
-require 'active_support/whiny_nil'
+require 'support/active_record_environment'
 
-module MachinistActiveRecordSpecs
-  
-  class Person < ActiveRecord::Base
-    attr_protected :password
-  end
+describe Machinist::ActiveRecord do
+  include ActiveRecordEnvironment
 
-  class Admin < Person
+  before(:each) do
+    Machinist::Shop.instance.reset!
+    empty_database!
   end
 
-  class Post < ActiveRecord::Base
-    has_many :comments
+  def fake_a_test
+    ActiveRecord::Base.transaction do
+      Machinist.reset_before_test
+      yield
+      raise ActiveRecord::Rollback
+    end
   end
 
-  class Comment < ActiveRecord::Base
-    belongs_to :post
-    belongs_to :author, :class_name => "Person"
+  context "make" do
+    it "should return an unsaved object" do
+      Post.blueprint { }
+      post = Post.make
+      post.should be_a(Post)
+      post.should be_new_record
+    end
   end
 
-  describe Machinist, "ActiveRecord adapter" do
-    before(:suite) do
-      ActiveRecord::Base.logger = Logger.new(File.dirname(__FILE__) + "/log/test.log")
-      ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :database => ":memory:")
-      load(File.dirname(__FILE__) + "/db/schema.rb")
+  context "make!" do
+    it "should make and save objects" do
+      Post.blueprint { }
+      post = Post.make!
+      post.should be_a(Post)
+      post.should_not be_new_record
     end
-  
-    before(:each) do
-      [Person, Admin, Post, Comment].each(&:clear_blueprints!)
+
+    it "should raise an exception for an invalid object" do
+      User.blueprint { }
+      lambda {
+        User.make!(:username => "")
+      }.should raise_error(ActiveRecord::RecordInvalid)
     end
-  
-    describe "make method" do
-      it "should support single-table inheritance" do
-        Person.blueprint { }
-        Admin.blueprint  { }
-        admin = Admin.make
-        admin.should_not be_new_record
-        admin.type.should == "Admin"
-      end
 
-      it "should save the constructed object" do
-        Person.blueprint { }
-        person = Person.make
-        person.should_not be_new_record
-      end
-  
-      it "should create an object through belongs_to association" do
-        Post.blueprint { }
-        Comment.blueprint { post }
-        Comment.make.post.class.should == Post
-      end
-  
-      it "should create an object through belongs_to association with a class_name attribute" do
-        Person.blueprint { }
-        Comment.blueprint { author }
-        Comment.make.author.class.should == Person
-      end
+    it "should buy objects from the shop" do
+      Post.blueprint { }
+      post_a, post_b = nil, nil
+      fake_a_test { post_a = Post.make! }
+      fake_a_test { post_b = Post.make! }
+      post_a.should == post_b
+    end
+  end
 
-      it "should create an object through belongs_to association using a named blueprint" do
-        Post.blueprint { }
-        Post.blueprint(:dummy) { title 'Dummy Post' }
-        Comment.blueprint { post(:dummy) }
-        Comment.make.post.title.should == 'Dummy Post'
-      end
-      
-      it "should allow creating an object through a has_many association" do
-        Post.blueprint do
-          comments { [Comment.make] }
-        end
-        Comment.blueprint { }
-        Post.make.comments.should have(1).instance_of(Comment)
-      end
-      
-      it "should allow setting a protected attribute in the blueprint" do
-        Person.blueprint do
-          password "Test"
-        end
-        Person.make.password.should == "Test"
-      end
-      
-      it "should allow overriding a protected attribute" do
-        Person.blueprint do
-          password "Test"
-        end
-        Person.make(:password => "New").password.should == "New"
-      end
-      
-      it "should allow setting the id attribute in a blueprint" do
-        Person.blueprint { id 12345 }
-        Person.make.id.should == 12345
-      end
-      
-      it "should allow setting the type attribute in a blueprint" do
-        Person.blueprint { type "Person" }
-        Person.make.type.should == "Person"
-      end
+  context "associations support" do
+    it "should handle belongs_to associations" do
+      User.blueprint do
+        username { "user_#{sn}" }
+      end
+      Post.blueprint do
+        author
+      end
+      post = Post.make!
+      post.should be_a(Post)
+      post.should_not be_new_record
+      post.author.should be_a(User)
+      post.author.should_not be_new_record
+    end
 
-      describe "on a has_many association" do
-        before do 
-          Post.blueprint { }
-          Comment.blueprint { post }
-          @post = Post.make
-          @comment = @post.comments.make
-        end
-    
-        it "should save the created object" do
-          @comment.should_not be_new_record
-        end
-    
-        it "should set the parent association on the created object" do
-          @comment.post.should == @post
-        end
+    it "should handle has_many associations" do
+      Post.blueprint do
+        comments(3)
+      end
+      Comment.blueprint { }
+      post = Post.make!
+      post.should be_a(Post)
+      post.should_not be_new_record
+      post.should have(3).comments
+      post.comments.each do |comment|
+        comment.should be_a(Comment)
+        comment.should_not be_new_record
       end
     end
 
-    describe "plan method" do
-      it "should not save the constructed object" do
-        person_count = Person.count
-        Person.blueprint { }
-        person = Person.plan
-        Person.count.should == person_count
+    it "should handle habtm associations" do
+      Post.blueprint do
+        tags(3)
       end
-  
-      it "should create an object through a belongs_to association, and return its id" do
-        Post.blueprint { }
-        Comment.blueprint { post }
-        post_count = Post.count
-        comment = Comment.plan
-        Post.count.should == post_count + 1
-        comment[:post].should be_nil
-        comment[:post_id].should_not be_nil
+      Tag.blueprint do
+        name { "tag_#{sn}" }
       end
-
-      describe "on a belongs_to association" do
-        it "should allow explicitly setting the association to nil" do
-          Comment.blueprint { post }
-          Comment.blueprint(:no_post) { post { nil } }
-          lambda {
-            @comment = Comment.plan(:no_post)
-          }.should_not raise_error
-        end
-      end
-  
-      describe "on a has_many association" do
-        before do
-          Post.blueprint { }
-          Comment.blueprint do
-            post
-            body { "Test" }
-          end
-          @post = Post.make
-          @post_count = Post.count
-          @comment = @post.comments.plan
-        end
-    
-        it "should not include the parent in the returned hash" do
-          @comment[:post].should be_nil
-          @comment[:post_id].should be_nil
-        end
-    
-        it "should not create an extra parent object" do
-          Post.count.should == @post_count
-        end
+      post = Post.make!
+      post.should be_a(Post)
+      post.should_not be_new_record
+      post.should have(3).tags
+      post.tags.each do |tag|
+        tag.should be_a(Tag)
+        tag.should_not be_new_record
       end
     end
 
-    describe "make_unsaved method" do
-      it "should not save the constructed object" do
-        Person.blueprint { }
-        person = Person.make_unsaved
-        person.should be_new_record
-      end
-  
-      it "should not save associated objects" do
-        Post.blueprint { }
-        Comment.blueprint { post }
-        comment = Comment.make_unsaved
-        comment.post.should be_new_record
-      end
-  
-      it "should save objects made within a passed-in block" do
-        Post.blueprint { }
-        Comment.blueprint { }
-        comment = nil
-        post = Post.make_unsaved { comment = Comment.make }
-        post.should be_new_record
-        comment.should_not be_new_record
-      end
+    it "should handle overriding associations" do
+      User.blueprint do
+        username { "user_#{sn}" }
+      end
+      Post.blueprint do
+        author { User.make!(:username => "post_author_#{sn}") }
+      end
+      post = Post.make!
+      post.should be_a(Post)
+      post.should_not be_new_record
+      post.author.should be_a(User)
+      post.author.should_not be_new_record
+      post.author.username.should =~ /^post_author_\d+$/
     end
-  
   end
+
+  context "error handling" do
+    it "should raise an exception for an attribute with no value" do
+      User.blueprint { username }
+      lambda {
+        User.make
+      }.should raise_error(ArgumentError)
+    end
+  end
+
 end