JamieFlournoy-machinist 1.0.6

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 && !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
+
+    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)
+      object = Machinist.with_save_nerfed { make(*args) }
+      yield object if block_given?
+      object
+    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,62 @@
+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)
+      object.class.association_reflection(attribute).associated_class
+    end
+
+    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
+          key = association[:key] || association.default_key
+          attributes[key] = value.send(association.primary_key)
+        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
+          lathe.object.refresh
+        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,81 @@
+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)
+    if args.empty? && !block_given? && @@shams[:name].nil? # workaround for ZenTest initializer
+      super
+    else
+      method_missing(:name, *args, &block)
+    end
+  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
+    result = @values[@offset]
+    @offset += 1
+    result
+  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

data/machinist.gemspec

@@ -0,0 +1,90 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{machinist}
+  s.version = "1.0.6"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Pete Yandell"]
+  s.date = %q{2010-03-23}
+  s.email = %q{pete@notahat.com}
+  s.extra_rdoc_files = [
+    "README.markdown"
+  ]
+  s.files = [
+    ".autotest",
+     ".gitignore",
+     "FAQ.markdown",
+     "MIT-LICENSE",
+     "README.markdown",
+     "Rakefile",
+     "VERSION",
+     "init.rb",
+     "lib/machinist.rb",
+     "lib/machinist/active_record.rb",
+     "lib/machinist/blueprints.rb",
+     "lib/machinist/data_mapper.rb",
+     "lib/machinist/object.rb",
+     "lib/machinist/sequel.rb",
+     "lib/sham.rb",
+     "machinist.gemspec",
+     "spec/active_record_spec.rb",
+     "spec/data_mapper_spec.rb",
+     "spec/db/.gitignore",
+     "spec/db/schema.rb",
+     "spec/log/.gitignore",
+     "spec/machinist_spec.rb",
+     "spec/sequel_spec.rb",
+     "spec/sham_spec.rb",
+     "spec/spec_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/notahat/machinist}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.6}
+  s.summary = %q{Fixtures aren't fun. Machinist is.}
+  s.test_files = [
+    "spec/active_record_spec.rb",
+     "spec/data_mapper_spec.rb",
+     "spec/db/schema.rb",
+     "spec/machinist_spec.rb",
+     "spec/sequel_spec.rb",
+     "spec/sham_spec.rb",
+     "spec/spec_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<rspec>, [">= 1.2.8"])
+      s.add_development_dependency(%q<activerecord>, [">= 0"])
+      s.add_development_dependency(%q<sequel>, [">= 0"])
+      s.add_development_dependency(%q<dm-core>, [">= 0"])
+      s.add_development_dependency(%q<dm-validations>, [">= 0"])
+      s.add_development_dependency(%q<data_objects>, [">= 0"])
+      s.add_development_dependency(%q<do_sqlite3>, [">= 0"])
+    else
+      s.add_dependency(%q<rspec>, [">= 1.2.8"])
+      s.add_dependency(%q<activerecord>, [">= 0"])
+      s.add_dependency(%q<sequel>, [">= 0"])
+      s.add_dependency(%q<dm-core>, [">= 0"])
+      s.add_dependency(%q<dm-validations>, [">= 0"])
+      s.add_dependency(%q<data_objects>, [">= 0"])
+      s.add_dependency(%q<do_sqlite3>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<rspec>, [">= 1.2.8"])
+    s.add_dependency(%q<activerecord>, [">= 0"])
+    s.add_dependency(%q<sequel>, [">= 0"])
+    s.add_dependency(%q<dm-core>, [">= 0"])
+    s.add_dependency(%q<dm-validations>, [">= 0"])
+    s.add_dependency(%q<data_objects>, [">= 0"])
+    s.add_dependency(%q<do_sqlite3>, [">= 0"])
+  end
+end
+