machinist 1.0.6 → 2.0

data/lib/generators/machinist/install/install_generator.rb

@@ -0,0 +1,46 @@
+module Machinist
+  module Generators #:nodoc:
+    class InstallGenerator < Rails::Generators::Base #:nodoc:
+      source_root File.expand_path('../templates', __FILE__)
+
+      class_option :test_framework, :type => :string, :aliases => "-t", :desc => "Test framework to use Machinist with"
+      class_option :cucumber, :type => :boolean, :desc => "Set up access to Machinist from Cucumber"
+
+      def blueprints_file
+        if rspec?
+          copy_file "blueprints.rb", "spec/support/blueprints.rb" 
+        else
+          copy_file "blueprints.rb", "test/blueprints.rb"
+        end
+      end
+
+      def test_helper
+        if test_unit?
+          inject_into_file("test/test_helper.rb", :after => "require 'rails/test_help'\n") do
+            "require File.expand_path(File.dirname(__FILE__) + '/blueprints')\n"
+          end
+        end
+      end
+
+      def cucumber_support
+        if cucumber?
+          template "machinist.rb.erb", "features/support/machinist.rb"
+        end
+      end
+
+    private
+
+      def rspec?
+        options[:test_framework].to_sym == :rspec
+      end
+
+      def test_unit?
+        options[:test_framework].to_sym == :test_unit
+      end
+
+      def cucumber?
+        options[:cucumber]
+      end
+    end
+  end
+end

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,7 @@
+<%- 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 -%>

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/active_record/blueprint.rb

@@ -0,0 +1,16 @@
+module Machinist::ActiveRecord
+  class Blueprint < Machinist::Blueprint
+
+    # Make and save an object.
+    def make!(attributes = {})
+      object = make(attributes)
+      object.save!
+      object.reload
+    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/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/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 to 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

data/lib/machinist/lathe.rb

@@ -0,0 +1,68 @@
+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.
+    def sn
+      @serial_number
+    end
+
+    # 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,95 @@
+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 = {}])
+    #
+    # Arguments are the same as for make.
+    def make!(*args)
+      decode_args_to_make(*args) do |blueprint, attributes|
+        raise BlueprintCantSaveError.new(blueprint) unless blueprint.respond_to?(:make!)
+        blueprint.make!(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/version.rb

@@ -0,0 +1,3 @@
+module Machinist
+  VERSION = "2.0"
+end

data/lib/machinist.rb

@@ -1,110 +1,5 @@
-require 'sham'
- 
-module Machinist
+require 'machinist/blueprint'
+require 'machinist/exceptions'
+require 'machinist/lathe'
+require 'machinist/machinable'
 
-  # 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
-
-    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
-
-  @@nerfed = false
-  def self.nerfed?
-    @@nerfed
-  end
-
-end