indirect-machinist 2.0.0.beta3

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.rb

@@ -0,0 +1,5 @@
+require 'machinist/blueprint'
+require 'machinist/exceptions'
+require 'machinist/lathe'
+require 'machinist/machinable'
+require 'machinist/railtie' if defined?(Rails::Railtie)

data/lib/machinist/active_record.rb

@@ -0,0 +1,14 @@
+require 'active_record'
+require 'machinist'
+require 'machinist/active_record/blueprint'
+require 'machinist/active_record/lathe'
+
+module ActiveRecord #:nodoc:
+  class Base #:nodoc:
+    extend Machinist::Machinable
+
+    def self.blueprint_class
+      Machinist::ActiveRecord::Blueprint
+    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/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/railtie.rb

@@ -0,0 +1,5 @@
+module Machinist
+  class Railtie < ::Rails::Railtie
+    config.generators.fixture_replacement :machinist
+  end
+end

data/lib/machinist/version.rb

@@ -0,0 +1,3 @@
+module Machinist
+  VERSION = "2.0.0.beta3"
+end

data/machinist.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "machinist/version"
+
+Gem::Specification.new do |s|
+  s.name     = "indirect-machinist"
+  s.version  = Machinist::VERSION
+  s.platform = Gem::Platform::RUBY
+  s.authors  = ["Pete Yandell"]
+  s.email    = ["pete@notahat.com"]
+  s.homepage = "http://github.com/notahat/machinist"
+  s.summary  = "Fixtures aren't fun. Machinist is."
+
+  s.rubyforge_project = "machinist"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency "activerecord"
+  s.add_development_dependency "mysql"
+  s.add_development_dependency "rake"
+  s.add_development_dependency "rcov"
+  s.add_development_dependency "rspec"
+  s.add_development_dependency "rdoc"
+end

data/spec/active_record_spec.rb

@@ -0,0 +1,108 @@
+require File.dirname(__FILE__) + '/spec_helper'
+require 'support/active_record_environment'
+
+describe Machinist::ActiveRecord do
+  include ActiveRecordEnvironment
+
+  before(:each) do
+    empty_database!
+  end
+
+  context "make" do
+    it "returns an unsaved object" do
+      Post.blueprint { }
+      post = Post.make
+      post.should be_a(Post)
+      post.should be_new_record
+    end
+  end
+
+  context "make!" do
+    it "makes and saves objects" do
+      Post.blueprint { }
+      post = Post.make!
+      post.should be_a(Post)
+      post.should_not be_new_record
+    end
+
+    it "raises an exception for an invalid object" do
+      User.blueprint { }
+      lambda {
+        User.make!(:username => "")
+      }.should raise_error(ActiveRecord::RecordInvalid)
+    end
+  end
+
+  context "associations support" do
+    it "handles 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
+
+    it "handles 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
+
+    it "handles habtm associations" do
+      Post.blueprint do
+        tags(3)
+      end
+      Tag.blueprint do
+        name { "tag_#{sn}" }
+      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
+
+    it "handles 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 "raises an exception for an attribute with no value" do
+      User.blueprint { username }
+      lambda {
+        User.make
+      }.should raise_error(ArgumentError)
+    end
+  end
+
+end