manufactory 0.0.1 → 0.0.2

data/lib/manufactory/adapters/activerecord.rb

@@ -0,0 +1,90 @@
+require 'manufactory'
+require 'manufactory/blueprints'
+require 'active_record'
+
+module Manufactory
+  class ActiveRecordAdapter
+    def self.has_association?(object, attribute)
+      object.class.reflect_on_association(attribute)
+    end
+    
+    def self.class_for_association(object, attribute)
+      association = object.class.reflect_on_association(attribute)
+      association && association.klass
+    end
+    
+    # This method takes care of converting any associated objects,
+    # in the hash returned by Lathe#assigned_attributes, into their
+    # object ids.
+    #
+    # For example, let's say we have blueprints like this:
+    #
+    #   Post.blueprint { }
+    #   Comment.blueprint { post }
+    #
+    # Lathe#assigned_attributes will return { :post => ... }, but
+    # we want to pass { :post_id => 1 } to a controller.
+    #
+    # This method takes care of cleaning this up.
+    def self.assigned_attributes_without_associations(lathe)
+      attributes = {}
+      lathe.assigned_attributes.each_pair do |attribute, value|
+        association = lathe.object.class.reflect_on_association(attribute)
+        if association && association.macro == :belongs_to && !value.nil?
+          attributes[association.primary_key_name.to_sym] = value.id
+        else
+          attributes[attribute] = value
+        end
+      end
+      attributes
+    end
+  end
+    
+  module ActiveRecordExtensions
+    def make(*args, &block)
+      lathe = Lathe.run(Manufactory::ActiveRecordAdapter, self.new, *args)
+      unless Manufactory.nerfed?
+        lathe.object.save!
+        lathe.object.reload
+      end
+      lathe.object(&block)
+    end
+
+    def make_unsaved(*args)
+      object = Manufactory.with_save_nerfed { make(*args) }
+      yield object if block_given?
+      object
+    end
+      
+    def plan(*args)
+      lathe = Lathe.run(Manufactory::ActiveRecordAdapter, self.new, *args)
+      Manufactory::ActiveRecordAdapter.assigned_attributes_without_associations(lathe)
+    end
+  end
+  
+  module ActiveRecordHasManyExtensions
+    def make(*args, &block)
+      lathe = Lathe.run(Manufactory::ActiveRecordAdapter, self.build, *args)
+      unless Manufactory.nerfed?
+        lathe.object.save!
+        lathe.object.reload
+      end
+      lathe.object(&block)
+    end
+
+    def plan(*args)
+      lathe = Lathe.run(Manufactory::ActiveRecordAdapter, self.build, *args)
+      Manufactory::ActiveRecordAdapter.assigned_attributes_without_associations(lathe)
+    end
+  end
+
+end
+
+class ActiveRecord::Base
+  extend Manufactory::Blueprints
+  extend Manufactory::ActiveRecordExtensions
+end
+
+class ActiveRecord::Associations::HasManyAssociation
+  include Manufactory::ActiveRecordHasManyExtensions
+end

data/lib/manufactory/adapters/datamapper.rb

@@ -1,3 +1,92 @@
 # encoding: utf-8
 
 require "manufactory"
+require "dm-core"
+require "dm-validations"
+
+module Manufactory
+  class DataMapperAdapter < GenericModelAdapter
+    def has_association?(object, attribute)
+      object.class.relationships.has_key?(attribute)
+    end
+    
+    def class_for_association(object, attribute)
+      association = object.class.relationships[attribute]
+      association && association.parent_model
+    end
+
+    def association_is_many_to_one?(association)
+      if defined?(DataMapper::Associations::ManyToOne::Relationship)
+        # We're using the next branch of DM
+        association.class == DataMapper::Associations::ManyToOne::Relationship
+      else
+        # We're using the 0.9 or less branch.
+        association.options[:max].nil?
+      end
+    end
+
+    # This method takes care of converting any associated objects,
+    # in the hash returned by Lathe#assigned_attributes, into their
+    # object ids.
+    #
+    # For example, let's say we have blueprints like this:
+    #
+    #   Post.blueprint { }
+    #   Comment.blueprint { post }
+    #
+    # Lathe#assigned_attributes will return { :post => ... }, but
+    # we want to pass { :post_id => 1 } to a controller.
+    #
+    # This method takes care of cleaning this up.
+    def assigned_attributes_without_associations(dsl)
+      attributes = {}
+      dsl.assigned_attributes.each_pair do |attribute, value|
+        association = dsl.object.class.relationships[attribute]
+        if association && association_is_many_to_one?(association)
+          # DataMapper child_key can have more than one property, but I'm not
+          # sure in what circumstances this would be the case. I'm assuming
+          # here that there's only one property.
+          key = association.child_key.map(&:field).first.to_sym
+          attributes[key] = value.id
+        else
+          attributes[attribute] = value
+        end
+      end
+      attributes
+    end
+  end
+
+  module DataMapperExtensions
+    include ManufactoryMixin
+    # Post.make
+    # Post.make(:named)
+    # Post.make(first_name: "Jakub")
+    # Post.make(named, first_name: "Jakub")
+    # Post.make(named, first_name: "Jakub") do
+    #   self.whatever = whatever
+    # end
+    def make(name = :default, attributes = Hash.new, &block)
+      instance = super(DataMapperAdapter, name, attributes, &block)
+      unless Manufactory.nerfed?
+        instance.save || raise("Save failed: #{instance.errors.full_messages.join(", ")}")
+        instance.reload
+      end
+      return instance
+    end
+
+    def make_unsaved(*args)
+      object = Manufactory.with_save_nerfed { make(*args) }
+      yield object if block_given?
+      object
+    end
+
+    def plan(*args)
+      adapter = Manufactory::DataMapperAdapter.new(self, *args)
+      dsl = DSL.new(adapter, object, blueprint).run
+      Manufactory::DataMapperAdapter.assigned_attributes_without_associations(dsl)
+    end
+  end
+end
+
+DataMapper::Validate::ClassMethods.send(:include, Manufactory::DataMapperExtensions)
+# DataMapper::Model.append_extensions(Manufactory::DataMapperExtensions)

data/lib/manufactory/adapters/generic_model.rb

@@ -0,0 +1,38 @@
+# encoding: utf-8
+
+# This is adapter for generic models,
+# so it call ModelClass.new(attributes) rather than
+# instance = ModelClass.new, attributes.each { |attribute, value| instance.send("#{attribute}="), value }
+# like it is in object adapter
+
+# Since this interface is generic, you have to register it before usage like:
+# HashStruct.extend(Manufactory::GenericObjectMixin)
+
+require "manufactory"
+
+module Manufactory
+  module GenericModelMixin
+    include ManufactoryMixin
+    # Post.make
+    # Post.make(:named)
+    # Post.make(first_name: "Jakub")
+    # Post.make(named, first_name: "Jakub")
+    # Post.make(named, first_name: "Jakub") do
+    #   self.whatever = whatever
+    # end
+    def make(name = :default, attributes = Hash.new, &block)
+      super(GenericModelAdapter, name, attributes, &block)
+    end
+  end
+
+  # ObjectAdapter.new(Object.new, *args)
+  class GenericModelAdapter < Adapter
+    def initialize_object(klass, default_attributes, attributes)
+      klass.new(default_attributes.merge(attributes))
+    end
+
+    def has_association?(object, attribute) # tohle nechceme zdedit!
+      false
+    end
+  end
+end

data/lib/manufactory/adapters/object.rb

@@ -4,43 +4,16 @@ require "manufactory"
 
 module Manufactory
   module ObjectMixin
-    # Post.make
-    # Post.make(:named)
-    # Post.make(first_name: "Jakub")
-    # Post.make(named, first_name: "Jakub")
-    # Post.make(named, first_name: "Jakub") do
-    #   self.whatever = whatever
-    # end
+    include ManufactoryMixin
     def make(name = :default, attributes = Hash.new, &block)
-      name, attributes = :default, name if name.is_a?(Hash) && attributes.empty?
-      callables = self.blueprints[name]
-      adapter = ObjectAdapter.new(self, name, callables)
-      instance = adapter.run(attributes)
-      instance.instance_eval(&block) if block_given?
-      return instance
+      super(ObjectAdapter, name, attributes, &block)
     end
   end
 
-  # ObjectAdapter.new(Object.new, *args)
-  # NOTE: first argument is an object, not a class!
   class ObjectAdapter < Adapter
-    def has_association?(object, attribute)
-      false
-    end
-    
-    protected
-    def initialize_object(klass, default_attributes, attributes)
-      attributes = default_attributes.merge(attributes)
-      instance   = klass.new
-      attributes.each do |attribute, value|
-        instance.send("#{attribute}=", value)
-      end
-      return instance
-    end
   end
 end
 
 class Object
-  extend Manufactory::Blueprints
   extend Manufactory::ObjectMixin
 end

data/lib/manufactory/adapters/sequel.rb

@@ -0,0 +1,62 @@
+require 'manufactory'
+require 'manufactory/blueprints'
+require 'sequel'
+
+module Manufactory
+  class SequelAdapter
+    def self.has_association?(object, attribute)
+      object.class.associations.include?(attribute)
+    end
+
+    def self.class_for_association(object, attribute)
+      object.class.association_reflection(attribute).associated_class
+    end
+
+    def self.assigned_attributes_without_associations(lathe)
+      attributes = {}
+      lathe.assigned_attributes.each_pair do |attribute, value|
+        association = lathe.object.class.association_reflection(attribute)
+        if association && association[:type] == :many_to_one
+          key = association[:key] || association.default_key
+          attributes[key] = value.send(association.primary_key)
+        else
+          attributes[attribute] = value
+        end
+      end
+      attributes
+    end
+  end
+
+  module SequelExtensions
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def make(*args, &block)
+        lathe = Lathe.run(Manufactory::SequelAdapter, self.new, *args)
+        unless Manufactory.nerfed?
+          lathe.object.save
+          lathe.object.refresh
+        end
+        lathe.object(&block)
+      end
+
+      def make_unsaved(*args)
+        returning(Manufactory.with_save_nerfed { make(*args) }) do |object|
+          yield object if block_given?
+        end
+      end
+
+      def plan(*args)
+        lathe = Lathe.run(Manufactory::SequelAdapter, self.new, *args)
+        Manufactory::SequelAdapter.assigned_attributes_without_associations(lathe)
+      end      
+    end
+  end
+end
+
+class Sequel::Model
+  include Manufactory::Blueprints
+  include Manufactory::SequelExtensions
+end

data/lib/manufactory/dsl.rb

@@ -0,0 +1,89 @@
+# encoding: utf-8
+
+module Manufactory
+  # DSL is used to execute the blueprint and construct an object.
+  # The blueprint is instance_eval'd against the Lathe.
+  class DSL
+    attr_reader :adapter, :object, :blueprint
+    def initialize(adapter, object, blueprint)
+      @adapter   = adapter
+      @blueprint = blueprint
+      @object    = object
+    end
+
+    def run
+      self.instance_eval(&self.blueprint)
+      assigned_attributes
+    end
+
+    def object
+      yield @object if block_given?
+      @object
+    end
+    
+    def method_missing(symbol, *args, &block)
+      if attribute_assigned?(symbol)
+        # If we've already assigned the attribute, return that.
+        self.object.send(symbol)
+      elsif @adapter.has_association?(self.object, symbol) && !nil_or_empty?(self.object.send(symbol))
+        # If the attribute is an association and is already assigned, return that.
+        self.object.send(symbol)
+      else
+        # Otherwise generate a value and assign it.
+        assigned_attributes[symbol] = generate_attribute_value(symbol, *args, &block)
+      end
+    end
+
+    def assigned_attributes
+      @assigned_attributes ||= {}
+    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)
+    
+    private
+    def nil_or_empty?(object)
+      object.respond_to?(:empty?) ? object.empty? : object.nil?
+    end
+    
+    def attribute_assigned?(key)
+      assigned_attributes.has_key?(key.to_sym)
+    end
+    
+    def generate_attribute_value(attribute, *args, &block)
+      if block_given?
+        # If we've got a block, use that to generate the value.
+        yield
+      else
+        # Otherwise, look for an association or a sham.
+        if @adapter.has_association?(object, attribute)
+          @adapter.class_for_association(object, attribute).make(args.first || {})
+        elsif args.empty?
+          Sham.send(attribute)
+        else
+          # If we've got a constant, just use that.
+          args.first
+        end
+      end
+    end
+  end
+
+  # This sets a flag that stops make from saving objects, so
+  # that calls to make from within a blueprint don't create
+  # anything inside make_unsaved.
+  def self.with_save_nerfed
+    begin
+      @@nerfed = true
+      yield
+    ensure
+      @@nerfed = false
+    end
+  end
+
+  @@nerfed = false
+  def self.nerfed?
+    @@nerfed
+  end
+end

data/spec/manufactory/adapters/activerecord_spec.rb

@@ -0,0 +1,196 @@
+require File.dirname(__FILE__) + '/spec_helper'
+require 'manufactory/active_record'
+require 'active_support/whiny_nil'
+
+module ManufactoryActiveRecordSpecs
+  
+  class Person < ActiveRecord::Base
+    attr_protected :password
+  end
+
+  class Admin < Person
+  end
+
+  class Post < ActiveRecord::Base
+    has_many :comments
+  end
+
+  class Comment < ActiveRecord::Base
+    belongs_to :post
+    belongs_to :author, :class_name => "Person"
+  end
+
+  describe Manufactory, "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")
+    end
+  
+    before(:each) do
+      [Person, Admin, Post, Comment].each do |model|
+        model.blueprints.clear
+      end
+    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 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
+
+      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
+      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
+      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
+      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
+      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
+    end
+  
+  end
+end