notahat-machinist 0.3.1 → 1.0.0

data/lib/machinist.rb

@@ -1,7 +1,4 @@
-require 'active_support'
-require 'active_record'
 require 'sham'
-require 'machinist/active_record'
  
 module Machinist
 
@@ -9,63 +6,95 @@ module Machinist
   #
   # The blueprint is instance_eval'd against the Lathe.
   class Lathe
-    def self.run(object, *args)
+    def self.run(adapter, object, *args)
       blueprint       = object.class.blueprint
       named_blueprint = object.class.blueprint(args.shift) if args.first.is_a?(Symbol)
-      attributes = args.pop || {}
+      attributes      = args.pop || {}
       raise "No blueprint for class #{object.class}" if blueprint.nil?
-      returning self.new(object, attributes) do |lathe|
+      returning self.new(adapter, object, attributes) do |lathe|
         lathe.instance_eval(&named_blueprint) if named_blueprint
         lathe.instance_eval(&blueprint)
       end
     end
     
-    def initialize(object, attributes = {})
-      @object = object
-      @assigned_attributes = {}
-      attributes.each do |key, value|
-        @object.send("#{key}=", value)
-        @assigned_attributes[key.to_sym] = value
-      end
+    def initialize(adapter, object, attributes = {})
+      @adapter = adapter
+      @object  = object
+      attributes.each {|key, value| assign_attribute(key, value) }
     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)
-    
     def object
       yield @object if block_given?
       @object
     end
     
-    attr_reader :assigned_attributes
-    
     def method_missing(symbol, *args, &block)
-      if @assigned_attributes.has_key?(symbol)
+      if attribute_assigned?(symbol)
+        # If we've already assigned the attribute, return that.
         @object.send(symbol)
-      elsif @object.class.reflect_on_association(symbol) && !@object.send(symbol).nil?
+      elsif @adapter.has_association?(@object, symbol) && !@object.send(symbol).nil?
+        # If the attribute is an association and is already assigned, return that.
         @object.send(symbol)
       else
-        @object.send("#{symbol}=", generate_attribute(symbol, args, &block))
+        # Otherwise generate a value and assign it.
+        assign_attribute(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 assign_attribute(key, value)
+      assigned_attributes[key.to_sym] = value
+      @object.send("#{key}=", value)
+    end
+  
+    def attribute_assigned?(key)
+      assigned_attributes.has_key?(key.to_sym)
+    end
     
-    def generate_attribute(attribute, args)
-      value = if block_given?
+    def generate_attribute_value(attribute, *args)
+      if block_given?
+        # If we've got a block, use that to generate the value.
         yield
-      elsif args.empty?
-        association = @object.class.reflect_on_association(attribute)
-        if association
-          association.class_name.constantize.make(args.first || {})
+      elsif !args.empty?
+        # If we've got a constant, just use that.
+        args.first
+      else
+        # Otherwise, look for an association or a sham.
+        if @adapter.has_association?(object, attribute)
+          @adapter.class_for_association(object, attribute).make(args.first || {})
         else
           Sham.send(attribute)
         end
-      else
-        args.first
       end
-      @assigned_attributes[attribute] = value
     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/lib/machinist/active_record.rb

@@ -1,9 +1,21 @@
+require 'machinist'
+require 'machinist/blueprints'
+
 module Machinist
   
-  module ActiveRecord
+  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_attributed, into their
+    # in the hash returned by Lathe#assigned_attributes, into their
     # object ids.
     #
     # For example, let's say we have blueprints like this:
@@ -28,89 +40,59 @@ module Machinist
       attributes
     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
-    
-    module Extensions
-      def self.included(base)
-        base.extend(ClassMethods)
-      end
+  end
     
-      module ClassMethods
-        def blueprint(name = :master, &blueprint)
-          @blueprints ||= {}
-          @blueprints[name] = blueprint if block_given?
-          @blueprints[name]
-        end
-        
-        def named_blueprints
-          @blueprints.reject{|name,_| name == :master }.keys
-        end
-        
-        def clear_blueprints!
-          @blueprints = {}
-        end
-
-        def make(*args, &block)
-          lathe = Lathe.run(self.new, *args)
-          unless Machinist::ActiveRecord.nerfed?
-            lathe.object.save!
-            lathe.object.reload
-          end
-          lathe.object(&block)
-        end
-
-        def make_unsaved(*args)
-          returning(Machinist::ActiveRecord.with_save_nerfed { make(*args) }) do |object|
-            yield object if block_given?
-          end
-        end
-          
-        def plan(*args)
-          lathe = Lathe.run(self.new, *args)
-          Machinist::ActiveRecord.assigned_attributes_without_associations(lathe)
-        end
-      end
+  module ActiveRecordExtensions
+    def self.included(base)
+      base.extend(ClassMethods)
     end
   
-    module BelongsToExtensions
+    module ClassMethods
       def make(*args, &block)
-        lathe = Lathe.run(self.build, *args)
-        unless Machinist::ActiveRecord.nerfed?
+        lathe = Lathe.run(Machinist::ActiveRecordAdapter, self.new, *args)
+        unless Machinist.nerfed?
           lathe.object.save!
           lathe.object.reload
         end
         lathe.object(&block)
       end
 
+      def make_unsaved(*args)
+        returning(Machinist.with_save_nerfed { make(*args) }) do |object|
+          yield object if block_given?
+        end
+      end
+        
       def plan(*args)
-        lathe = Lathe.run(self.build, *args)
-        Machinist::ActiveRecord.assigned_attributes_without_associations(lathe)
+        lathe = Lathe.run(Machinist::ActiveRecordAdapter, self.new, *args)
+        Machinist::ActiveRecordAdapter.assigned_attributes_without_associations(lathe)
       end
     end
+  end
   
+  module ActiveRecordHasManyExtensions
+    def make(*args, &block)
+      lathe = Lathe.run(Machinist::ActiveRecordAdapter, self.build, *args)
+      unless Machinist.nerfed?
+        lathe.object.save!
+        lathe.object.reload
+      end
+      lathe.object(&block)
+    end
+
+    def plan(*args)
+      lathe = Lathe.run(Machinist::ActiveRecordAdapter, self.build, *args)
+      Machinist::ActiveRecordAdapter.assigned_attributes_without_associations(lathe)
+    end
   end
-end
 
+end
 
 class ActiveRecord::Base
-  include Machinist::ActiveRecord::Extensions
+  include Machinist::Blueprints
+  include Machinist::ActiveRecordExtensions
 end
 
-class ActiveRecord::Associations::BelongsToAssociation
-  include Machinist::ActiveRecord::BelongsToExtensions
+class ActiveRecord::Associations::HasManyAssociation
+  include Machinist::ActiveRecordHasManyExtensions
 end

data/lib/machinist/blueprints.rb

@@ -0,0 +1,25 @@
+module Machinist
+  # Include this in a class to allow defining blueprints for that class.
+  module Blueprints
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+    
+    module ClassMethods
+      def blueprint(name = :master, &blueprint)
+        @blueprints ||= {}
+        @blueprints[name] = blueprint if block_given?
+        @blueprints[name]
+      end
+    
+      def named_blueprints
+        @blueprints.reject{|name,_| name == :master }.keys
+      end
+    
+      def clear_blueprints!
+        @blueprints = {}
+      end
+    end
+    
+  end
+end

data/lib/machinist/data_mapper.rb

@@ -0,0 +1,83 @@
+require 'machinist'
+require 'machinist/blueprints'
+require 'dm-core'
+
+module Machinist
+  
+  class DataMapperAdapter
+    def self.has_association?(object, attribute)
+      object.class.relationships.has_key?(attribute)
+    end
+    
+    def self.class_for_association(object, attribute)
+      association = object.class.relationships[attribute]
+      association && association.parent_model
+    end
+
+    def self.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 self.assigned_attributes_without_associations(lathe)
+      attributes = {}
+      lathe.assigned_attributes.each_pair do |attribute, value|
+        association = lathe.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
+    def make(*args, &block)
+      lathe = Lathe.run(Machinist::DataMapperAdapter, self.new, *args)
+      unless Machinist.nerfed?
+        lathe.object.save || raise("Save failed")
+        lathe.object.reload
+      end
+      lathe.object(&block)
+    end
+
+    def make_unsaved(*args)
+      returning(Machinist.with_save_nerfed { make(*args) }) do |object|
+        yield object if block_given?
+      end
+    end
+
+    def plan(*args)
+      lathe = Lathe.run(Machinist::DataMapperAdapter, self.new, *args)
+      Machinist::DataMapperAdapter.assigned_attributes_without_associations(lathe)
+    end
+  end
+
+end
+
+DataMapper::Model.append_extensions(Machinist::Blueprints::ClassMethods)
+DataMapper::Model.append_extensions(Machinist::DataMapperExtensions)

data/lib/machinist/object.rb

@@ -0,0 +1,30 @@
+require 'machinist'
+require 'machinist/blueprints'
+
+module Machinist
+  
+  module ObjectExtensions
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+  
+    module ClassMethods
+      def make(*args, &block)
+        lathe = Lathe.run(Machinist::ObjectAdapter, self.new, *args)
+        lathe.object(&block)
+      end
+    end
+  end
+  
+  class ObjectAdapter
+    def self.has_association?(object, attribute)
+      false
+    end
+  end
+  
+end
+
+class Object
+  include Machinist::Blueprints
+  include Machinist::ObjectExtensions
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: notahat-machinist
 version: !ruby/object:Gem::Version 
-  version: 0.3.1
+  version: 1.0.0
 platform: ruby
 authors: 
 - Pete Yandell
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-02-25 00:00:00 -08:00
+date: 2009-05-16 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -24,7 +24,10 @@ extra_rdoc_files: []
 files: 
 - lib/machinist.rb
 - lib/sham.rb
+- lib/machinist/blueprints.rb
+- lib/machinist/object.rb
 - lib/machinist/active_record.rb
+- lib/machinist/data_mapper.rb
 has_rdoc: false
 homepage: http://github.com/notahat/machinist
 post_install_message: