machinist 1.0.6 → 2.0.0.beta1

data/lib/generators/machinist/install/templates/blueprints.rb

@@ -0,0 +1,9 @@
+require 'machinist/active_record'
+
+# Add your blueprints here.
+#
+# e.g.
+#   Post.blueprint do
+#     title { "Post #{sn}" }
+#     body  { "Lorem ipsum..." }
+#   end

data/lib/generators/machinist/install/templates/machinist.rb.erb

@@ -0,0 +1,10 @@
+<%- if rspec? -%>
+# Load the blueprints from over in spec support.
+require "#{Rails.root}/spec/support/blueprints"
+<%- else -%>
+# Load the blueprints from over in test.
+require "#{Rails.root}/test/blueprints"
+<%- end -%>
+
+# Reset the Machinist cache before each scenario.
+Before { Machinist.reset_before_test }

data/lib/generators/machinist/model/model_generator.rb

@@ -0,0 +1,13 @@
+module Machinist
+  module Generators #:nodoc:
+    class ModelGenerator < Rails::Generators::NamedBase #:nodoc:
+      argument :attributes, :type => :array, :default => [], :banner => "field:type field:type"
+
+      def create_blueprint
+        append_file "spec/support/blueprints.rb", "\n#{class_name}.blueprint do\n  # Attributes here\nend\n"
+      end
+
+    end
+  end
+end
+

data/lib/machinist.rb

@@ -1,110 +1,16 @@
-require 'sham'
- 
-module Machinist
-
-  # A Lathe is used to execute the blueprint and construct an object.
-  #
-  # The blueprint is instance_eval'd against the Lathe.
-  class Lathe
-    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 || {}
-
-      raise "No blueprint for class #{object.class}" if blueprint.nil?
-
-      lathe = self.new(adapter, object, attributes)
-      lathe.instance_eval(&named_blueprint) if named_blueprint
-      klass = object.class
-      while klass
-        lathe.instance_eval(&klass.blueprint) if klass.respond_to?(:blueprint) && klass.blueprint
-        klass = klass.superclass
-      end
-      lathe
-    end
-    
-    def initialize(adapter, object, attributes = {})
-      @adapter = adapter
-      @object  = object
-      attributes.each {|key, value| assign_attribute(key, value) }
-    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.
-        @object.send(symbol)
-      elsif @adapter.has_association?(@object, symbol) && !nil_or_empty?(@object.send(symbol))
-        # If the attribute is an association and is already assigned, return that.
-        @object.send(symbol)
-      else
-        # Otherwise generate a value and assign it.
-        assign_attribute(symbol, generate_attribute_value(symbol, *args, &block))
-      end
-    end
+require 'machinist/blueprint'
+require 'machinist/exceptions'
+require 'machinist/lathe'
+require 'machinist/machinable'
+require 'machinist/shop'
+require 'machinist/warehouse'
 
-    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 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_value(attribute, *args)
-      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
+module Machinist
 
-  @@nerfed = false
-  def self.nerfed?
-    @@nerfed
+  # Call this before each test to get Machinist ready.
+  def self.reset_before_test
+    Shop.instance.restock
   end
 
 end
+

data/lib/machinist/active_record.rb

@@ -1,99 +1,14 @@
-require 'machinist'
-require 'machinist/blueprints'
 require 'active_record'
+require 'machinist'
+require 'machinist/active_record/blueprint'
+require 'machinist/active_record/lathe'
 
-module Machinist
-  
-  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 self.included(base)
-      base.extend(ClassMethods)
-    end
-  
-    module ClassMethods
-      def make(*args, &block)
-        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)
-        object = Machinist.with_save_nerfed { make(*args) }
-        yield object if block_given?
-        object
-      end
-        
-      def plan(*args)
-        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
+module ActiveRecord #:nodoc:
+  class Base #:nodoc:
+    extend Machinist::Machinable
 
-    def plan(*args)
-      lathe = Lathe.run(Machinist::ActiveRecordAdapter, self.build, *args)
-      Machinist::ActiveRecordAdapter.assigned_attributes_without_associations(lathe)
+    def self.blueprint_class
+      Machinist::ActiveRecord::Blueprint
     end
   end
-
-end
-
-class ActiveRecord::Base
-  include Machinist::Blueprints
-  include Machinist::ActiveRecordExtensions
-end
-
-class ActiveRecord::Associations::HasManyAssociation
-  include Machinist::ActiveRecordHasManyExtensions
 end

data/lib/machinist/active_record/blueprint.rb

@@ -0,0 +1,41 @@
+module Machinist::ActiveRecord
+  class Blueprint < Machinist::Blueprint
+
+    # Make and save an object.
+    def make!(attributes = {})
+      object = make(attributes)
+      object.save!
+      object.reload
+    end
+
+    # Box an object for storage in the warehouse.
+    def box(object)
+      object.id
+    end
+   
+    # Unbox an object from the warehouse.
+    def unbox(id)
+      @klass.find(id)
+    end
+
+    # Execute a block on a separate database connection, so that any database
+    # operations happen outside any open transactions.
+    def outside_transaction
+      # ActiveRecord manages connections per-thread, so the only way to
+      # convince it to open another connection is to start another thread.
+      thread = Thread.new do
+        begin
+          yield
+        ensure
+          ::ActiveRecord::Base.connection_pool.checkin(::ActiveRecord::Base.connection)
+        end
+      end
+      thread.value
+    end
+
+    def lathe_class #:nodoc:
+      Machinist::ActiveRecord::Lathe
+    end
+
+  end
+end

data/lib/machinist/active_record/lathe.rb

@@ -0,0 +1,24 @@
+module Machinist::ActiveRecord
+
+  class Lathe < Machinist::Lathe
+
+    def make_one_value(attribute, args) #:nodoc:
+      if block_given?
+        raise_argument_error(attribute) unless args.empty?
+        yield
+      else
+        make_association(attribute, args)
+      end
+    end
+
+    def make_association(attribute, args) #:nodoc:
+      association = @klass.reflect_on_association(attribute)
+      if association
+        association.klass.make(*args)
+      else
+        raise_argument_error(attribute)
+      end
+    end
+
+  end
+end

data/lib/machinist/blueprint.rb

@@ -0,0 +1,89 @@
+module Machinist
+
+  # A Blueprint defines a method of constructing objects of a particular class.
+  class Blueprint
+
+    # Construct a blueprint for the given +klass+.
+    #
+    # Pass in the +:parent+ option do define a parent blueprint to apply after
+    # this one.  You can supply another blueprint, or a class in which to look
+    # for a blueprint.  In the latter case, make will walk up the superclass
+    # chain looking for blueprints to apply.
+    def initialize(klass, options = {}, &block)
+      @klass  = klass
+      @parent = options[:parent]
+      @block  = block
+    end
+
+    attr_reader :klass, :parent, :block
+
+    # Generate an object from this blueprint.
+    #
+    # Pass in attributes to override values defined in the blueprint.
+    def make(attributes = {})
+      lathe = lathe_class.new(@klass, new_serial_number, attributes)
+
+      lathe.instance_eval(&@block)
+      each_ancestor {|blueprint| lathe.instance_eval(&blueprint.block) }
+
+      lathe.object
+    end
+
+    # Returns the Lathe class used to make objects for this blueprint.
+    #
+    # Subclasses can override this to substitute a custom lathe class.
+    def lathe_class
+      Lathe
+    end
+
+    # Returns the parent blueprint for this blueprint.
+    def parent_blueprint
+      case @parent
+        when nil
+          nil
+        when Blueprint
+          # @parent references the parent blueprint directly.
+          @parent
+        else
+          # @parent is a class in which we should look for a blueprint.
+          find_blueprint_in_superclass_chain(@parent)
+      end
+    end
+    
+    # Yields the parent blueprint, its parent blueprint, etc.
+    def each_ancestor
+      ancestor = parent_blueprint
+      while ancestor
+        yield ancestor
+        ancestor = ancestor.parent_blueprint
+      end
+    end
+
+  protected
+
+    def new_serial_number  #:nodoc:
+      parent_blueprint = self.parent_blueprint  # Cache this for speed.
+      if parent_blueprint
+        parent_blueprint.new_serial_number
+      else
+        @serial_number ||= 0
+        @serial_number += 1
+        sprintf("%04d", @serial_number)
+      end
+    end
+
+  private
+
+    def find_blueprint_in_superclass_chain(klass)
+      until has_blueprint?(klass) || klass.nil?
+        klass = klass.superclass
+      end
+      klass && klass.blueprint
+    end
+
+    def has_blueprint?(klass)
+      klass.respond_to?(:blueprint) && !klass.blueprint.nil?
+    end
+
+  end
+end

data/lib/machinist/exceptions.rb

@@ -0,0 +1,32 @@
+module Machinist
+
+  # Raised when make! is called on a class whose blueprints don't support
+  # saving.
+  class BlueprintCantSaveError < RuntimeError
+    attr_reader :blueprint
+
+    def initialize(blueprint)
+      @blueprint = blueprint
+    end
+
+    def message
+      "make! is not supported by blueprints for class #{@blueprint.klass.name}"
+    end
+  end
+
+  # Raised when calling make on a class with no corresponding blueprint
+  # defined.
+  class NoBlueprintError < RuntimeError
+    attr_reader :klass, :name
+
+    def initialize(klass, name)
+      @klass = klass
+      @name  = name
+    end
+
+    def message
+      "No #{@name} blueprint defined for class #{@klass.name}"
+    end
+  end
+
+end