pk-machinist 1.0.3

data/lib/machinist.rb

@@ -0,0 +1,100 @@
+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?
+      returning self.new(adapter, object, attributes) do |lathe|
+        lathe.instance_eval(&named_blueprint) if named_blueprint
+        lathe.instance_eval(&blueprint)
+      end
+    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) && !@object.send(symbol).nil?
+        # 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 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
+      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
+      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/lib/machinist/active_record.rb

@@ -0,0 +1,99 @@
+require 'machinist'
+require 'machinist/blueprints'
+require 'active_record'
+
+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
+          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)
+        returning(Machinist.with_save_nerfed { make(*args) }) do |object|
+          yield object if block_given?
+        end
+      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
+
+    def plan(*args)
+      lathe = Lathe.run(Machinist::ActiveRecordAdapter, self.build, *args)
+      Machinist::ActiveRecordAdapter.assigned_attributes_without_associations(lathe)
+    end
+  end
+
+end
+
+class ActiveRecord::Base
+  include Machinist::Blueprints
+  include Machinist::ActiveRecordExtensions
+end
+
+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

data/lib/machinist/sequel.rb

@@ -0,0 +1,81 @@
+require 'machinist'
+require 'machinist/blueprints'
+require 'sequel'
+
+module Machinist
+
+  class SequelAdapter
+
+    def self.has_association?(object, attribute)
+      object.class.associations.include? attribute
+    end
+
+    def self.class_for_association(object, attribute)
+      association = object.class.association_reflection(attribute)
+      association && Module.const_get(association[:class_name].to_sym)
+    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.association_reflection(attribute)
+        if association && association[:type] == :many_to_one
+          attributes[association[:key]] = value.id
+        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(Machinist::SequelAdapter, 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::SequelAdapter, self.new, *args)
+        Machinist::SequelAdapter.assigned_attributes_without_associations(lathe)
+      end
+
+    end
+  end
+
+end
+
+class Sequel::Model
+  include Machinist::Blueprints
+  include Machinist::SequelExtensions
+end

data/lib/sham.rb

@@ -0,0 +1,79 @@
+require 'active_support'
+
+class Sham
+  @@shams = {}
+  
+  # Over-ride module's built-in name method, so we can re-use it for
+  # generating names. This is a bit of a no-no, but we get away with
+  # it in this context.
+  def self.name(*args, &block)
+    method_missing(:name, *args, &block)
+  end
+  
+  def self.method_missing(symbol, *args, &block)
+    if block_given?
+      @@shams[symbol] = Sham.new(symbol, args.pop || {}, &block)
+    else
+      sham = @@shams[symbol]
+      raise "No sham defined for #{symbol}" if sham.nil?
+      sham.fetch_value
+    end
+  end
+  
+  def self.clear
+    @@shams = {}
+  end
+
+  def self.reset(scope = :before_all)
+    @@shams.values.each { |sham| sham.reset(scope) }
+  end
+  
+  def self.define(&block)
+    Sham.instance_eval(&block)
+  end
+  
+  def initialize(name, options = {}, &block)
+    @name      = name
+    @generator = block
+    @offset    = 0
+    @unique    = options.has_key?(:unique) ? options[:unique] : true
+    generate_values(12)
+  end
+  
+  def reset(scope)
+    if scope == :before_all
+      @offset, @before_offset = 0, nil
+    elsif @before_offset
+      @offset = @before_offset
+    else
+      @before_offset = @offset
+    end
+  end
+  
+  def fetch_value
+    # Generate more values if we need them.
+    if @offset >= @values.length
+      generate_values(2 * @values.length)
+      raise "Can't generate more unique values for Sham.#{@name}" if @offset >= @values.length
+    end
+    returning @values[@offset] do
+      @offset += 1
+    end
+  end
+    
+private
+  
+  def generate_values(count)
+    @values = seeded { (1..count).map(&@generator) }
+    @values.uniq! if @unique
+  end
+  
+  def seeded
+    begin
+      srand(1)
+      yield
+    ensure
+      srand
+    end
+  end
+end

metadata

@@ -0,0 +1,59 @@
+--- !ruby/object:Gem::Specification 
+name: pk-machinist
+version: !ruby/object:Gem::Version 
+  version: 1.0.3
+platform: ruby
+authors: 
+- Pete Yandell
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-05-16 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: 
+email: pete@nothat.com
+executables: []
+
+extensions: []
+
+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
+- lib/machinist/sequel.rb
+has_rdoc: false
+homepage: http://github.com/notahat/machinist
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Fixtures aren't fun. Machinist is.
+test_files: []
+