object_momma 0.9.0

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in object_momma.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 ntl
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,197 @@
+# ObjectMomma
+
+An Object Mother implementation in ruby
+
+## Description
+
+ObjectMomma is a gem that implements the Object Mother pattern for managing test data. It shares a lot of goals with FactoryGirl, but represents a fundamentally different approach.  See [this article by Martin Fowler](http://martinfowler.com/bliki/ObjectMother.html) for more information.
+
+## Vs. Fixtures and Factories
+
+The Object Mother pattern shares some benefits with fixtures -- namely, by assigning fixed names (I call them *child identifiers*) to the objects you define, you can mentally associate the properties of each object with those names. For instance, the user called "Joe Spammer" may be used pervasively throughout tests that cover comment moderation. You can even build larger scenarios that can be re-used over and over by your team.
+
+However, unlike fixtures, instead of managing yml files that directly manipulate database state, you can build out your objects in ruby with all of your model behaviors available. In this way, you get some of the best benefits of both fixtures and traditional factories.
+
+The biggest benefit of Object Mother over both fixtures and factories is that they are not tied to ActiveRecord, so you can actually use ObjectMomma to refactor your entire model structure if you need to. ObjectMomma's goal is to facilitate data set up for your acceptance tests, not unit tests, so there is no reason that you couldn't use ObjectMomma alongside FactoryGirl or fixtures. This approach is similar to using cucumber for acceptance tests and rspec or Test::Unit for your unit/controller tests.
+
+## Installation
+
+Install the gem locally:
+
+    gem install object_momma
+
+Or add it to your Gemfile:
+
+    gem 'object_momma'
+
+and run `bundle install` from your shell.
+
+## Usage
+
+### How your spec should look
+
+`rspec/capybara`:
+
+    feature "Moderating comments" do
+      let(:post) do
+        ObjectMomma.post("Birds")
+       end
+       
+      background do
+        ObjectMomma.spawn_comment("Joe Schmoe's Comment on the Post about Birds")
+      end
+      
+      scenario "Up voting a comment" do
+        visit post_path(post)
+        # etc.
+      end
+    end
+
+`Test::Unit`:
+
+    class CommentModeration < ActionController::IntegrationTest
+      def setup
+        @post = ObjectMomma.post("Birds")
+        ObjectMomma.spawn_post("Joe Schmoe's Comment on the Post About Birds")
+      end
+      
+      def test_upvoting_a_comment
+        visit post_path(post)
+        # etc.
+      end
+    end
+
+### Using ObjectMomma
+
+To create new objects, use methods that start with `ObjectMomma.spawn_*`, e.g. `ObjectMomma.spawn_user`:
+
+    => user = ObjectMomma.spawn_user("Joe Schmoe")
+    -> <#User:0xdeadbeef>
+
+In this case above, "Joe Schmoe" can be thought of as the *child identifier* for the particular child we're creating.
+ 
+Some objects are composed of other objects, and they can actually nest those child identifiers neatly, e.g. `Joe Schmoe's Comment on the Post about Birds.` You can spawn them by either referring to their composite child identifier, or by a hash mapping the associated object names to their identifiers:
+
+    => comment = ObjectMomma.spawn_comment("Joe Schmoe's Comment on the Post about Birds")
+    => comment = ObjectMomma.spawn_comment(user: "Joe Schmoe", post: "Birds")
+
+`ObjectMomma.spawn_*` will raise an `ObjectMomma::ObjectExists` exception if the object has already been spawned. To simply return the object if it does exist, omit the `spawn_` and invoke ObjectMomma thusly:
+
+    => ObjectMomma.spawn("Joe Schmoe") # Works the first time
+    => ObjectMomma.spawn("Joe Schmoe") # Now raises an ObjectExists exception
+    => ObjectMomma.user("Joe Schmoe")  # Works fine :)
+
+If you want to raise an error if the object *doesn't* exist, then `ObjectMomma.find_*` will raise an `ObjectMomma::ObjectNotFound` exception in that case:
+
+    => ObjectMomma.find("Joe Schmoe")  # Raises ObjectNotFound exception
+    => ObjectMomma.spawn("Joe Schmoe") # Works fine :)
+    => ObjectMomma.find("Joe Schmoe")  # Does not raise exception
+
+You can also build a bunch of objects all at once with `ObjectMomma.spawn`:
+
+    => ObjectMomma.spawn({
+         posts:   ["Birds", "Middle Earth", "Sports"],
+         users:   ["Joe Schmoe", "Scott Pilgrim"],
+         comment: "Billy Pilgrim's Comment on Post about Cooking"
+       })
+
+The idea with the single call to `ObjectMomma.spawn` is to be able to encapsulate complicated data setup with a simple, semantic call.
+
+### Teaching ObjectMomma how to build new types of objects
+
+The examples above assumed that ObjectMomma knew how to build out the objects in question. To actually teach ObjectMomma how to build the objects, consider:
+
+In `spec/object_momma/user.rb`:
+
+    class ObjectMomma::UserBuilder < ObjectMomma::Builder
+      def first_or_initialize
+        User.where(full_name: self.child_id)
+      end
+      
+      def build!(user)
+        user.full_name = child.child_id
+      end
+    end
+    
+The method `#first_or_initialize` has the most important role of the builder: it grabs the object from the persistence layer if it exists, otherwise, it initializes a new object.
+
+After grabbing an object from `#first_or_initialize`, ObjectMomma will invoke `#build!` if and only if the object hasn't yet been persisted. `#build!` will actually set up the data and persist the object itself.
+
+#### Composed Builders
+
+You can also implement builders that know how to compose objects from their associated objects:
+
+    class ObjectMomma::CommentBuilder < ObjectMomma::Builder
+      child_id { "#{author}'s Comment on #{post}" }
+      has_siblings :post, author: user
+      
+      def first_or_initialize
+        Comment.where(user_id: self.author.id, post_id: self.post.id)
+      end
+      
+      def build!(object)
+        if object.user.spammer?
+          object.text = "Check out teh cheap pillz from mycheappillz.com!!!"
+        elsif object.post.subject == :birds
+          # etc. …
+        end
+      end
+    end
+
+It is important to note the distinction between `self` and `object` in these cases.  `self` refers to the builder which has been hydrated with properties from the `child_id` block, whereas `object` refers to the child object itself.
+
+### But I don't *want* to use ActiveRecord!
+
+The only requirement ObjectMomma imposes on the objects that are spawned via your `first_or_initialize` methods is that they respond to `#persisted?` the way ActiveRecord objects do.  The gem itself does not depend on ActiveRecord at all; feel free to use whatever persistence layer you want. Consider overriding `ObjectMomma::Builder.is_persisted?` if your objects don't respond to `#persisted?`.
+
+Your builder's `first_or_initialize` method can return a Scope, as well. ObjectMomma will simply call `first_or_initialize` for you.
+
+### Serialized Attributes
+
+Supplying all the fictional data for your different children can be tedious and ugly. You may want to store canned attributes for your objects in YAML files, similar to fixtures. This features is completely optional. The attributes will get passed to your builders' #build! method as the second argument. An empty hash will be supplied if ObjectMomma couldn't find and parse the attributes for you. Example:
+
+    # spec/object_momma/user_builder.rb
+    class ObjectMomma::UserBuilder
+      …
+      
+      def build!(user, attributes)
+        user.attributes = attributes
+      end
+      
+      …
+    end
+
+The YAML file:
+
+    # spec/object_momma/attributes/users.yml
+    Scott Pilgrim:
+      username: "scott_pilgrim"
+      email:    "spilgrim@zz.zzz"
+
+To use:
+
+    => ObjectMother.spawn("Scott Pilgrim")
+    -> #<User:0xdeadbeef @username="scott_pilgrim", @email="spilgrim@zz.zzz", …>
+
+### Business in the front, party in the back
+
+If you'd like to refer to ObjectMomma via the constant ObjectMother, then have it your way:
+
+In `spec/spec_helper.rb`, add `ObjectMomma.mullet!` somewhere.  Then:
+
+    => ObjectMother.spawn_user("Joe Dirt")
+
+## More Information
+
+ * [ObjectMomma by Martin Fowler](http://martinfowler.com/bliki/ObjectMother.html)
+
+### Credits
+
+ObjectMomma was written by Nathan Ladd, with help from a few partners in crime:
+
+ * Josh Flanagan (jflanagan on github)
+ * Theo Mills
+
+And, of course, I read about the ObjectMother pattern that I ruined^H^H^H^Himplemented from:
+
+ * Martin Fowler

data/Rakefile

@@ -0,0 +1,20 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+
+task :console do
+  require "pp"
+  require "irb"
+
+  require "object_momma"
+  ObjectMomma.mullet!
+
+  require File.join(File.dirname(__FILE__), "spec/fixtures/blog_post_voting_classes")
+
+  ARGV.clear
+  IRB.start
+end
+
+require "rspec/core/rake_task"
+RSpec::Core::RakeTask.new('spec')
+
+task :default => :spec

data/lib/object_momma/builder.rb

@@ -0,0 +1,164 @@
+module ObjectMomma
+  VALID_IDENTIFIER_CHARS = %q{-\w\s_'\"\.}
+
+  class Builder
+    extend ObjectMomma::ClassAttributes
+
+    class_attribute :child_id_serializer, :siblings
+
+    attr_reader :child
+    private :child
+
+    def build_child_from_hash(hash, &block)
+      if has_child_id_serializer?
+        child.child_id = self.class.run_with_binding(hash)
+
+        hash.each do |name, value|
+          if has_siblings?
+            sibling_object_type = self.class.siblings[name]
+            if sibling_object_type
+              if value.is_a?(ObjectMomma::Child)
+                child = value
+              else
+                child = yield(sibling_object_type, value)
+              end
+              value = child.child_object
+            end
+          end
+
+          ivar_name = "@#{name}"
+          instance_variable_set(ivar_name, value)
+          self.singleton_class.instance_exec(name, ivar_name) do |name, ivar_name|
+            define_method(name) { instance_variable_get(ivar_name) }
+          end
+        end
+      else
+        child.child_id = hash.delete(:child_id)
+      end
+    end
+
+    def build!(*args)
+      raise Objectmomma::SubclassNotImplemented
+    end
+
+    def child_id
+      child.child_id
+    end
+
+    def initialize(child)
+      @child = child
+    end
+
+    def is_persisted?(object)
+      if object.respond_to?(:persisted?)
+        object.persisted?
+      else
+        raise ObjectMomma::SubclassNotImplemented, "Override #is_persisted? "\
+          "to support objects that do not respond to #persisted?"
+      end
+    end
+
+    def self.builder_for(object_type)
+      if ObjectMomma.builder_path
+        builder_file = File.join(ObjectMomma.builder_path, "#{object_type}_builder.rb")
+        require builder_file if File.size?(builder_file)
+      end
+
+      classified_name = "_#{object_type}Builder".gsub(/_\w/) do |underscored|
+        underscored[1].upcase
+      end
+
+      ObjectMomma.const_get(classified_name)
+    end
+
+    def self.has_child_id_serializer?
+      self.child_id_serializer.respond_to?(:to_proc)
+    end
+
+    def self.has_siblings?
+      self.siblings.is_a?(Hash)
+    end
+
+    def self.run_with_binding(props = {}, &block)
+      Object.new.tap do |o|
+        props.each do |name, value|
+          ivar_name = "@#{name}".to_sym
+          o.singleton_class.class_eval do
+            define_method(name) { instance_variable_get(ivar_name) }
+          end
+          o.instance_variable_set(ivar_name, value)
+        end
+
+        o.singleton_class.class_eval(&block) if block_given?
+      end.instance_exec(&child_id_serializer)
+    end
+
+    def self.string_to_hash(object_type, string)
+      builder = builder_for(object_type)
+
+      if builder.has_child_id_serializer?
+        vars = []
+
+        builder.run_with_binding(vars: vars) do
+          def method_missing(sym, *args, &block)
+            return super unless args.empty? && !block_given?
+            vars << sym unless vars.include?(sym)
+          end
+        end
+
+        string_matcher = "([#{VALID_IDENTIFIER_CHARS}]+)"
+        regex_string = builder.run_with_binding(string_matcher: string_matcher) do
+          def method_missing(sym, *args, &block)
+            return super unless args.empty? && !block_given?
+            string_matcher
+          end
+        end
+
+        regex = Regexp.new("^#{regex_string}$")
+        matches = string.match(regex).to_a[1..-1]
+
+        if matches.nil?
+          raise BadChildIdentifier, "Bad child_id `#{string}' for builder "\
+            "`#{name}'"
+        end
+
+        Hash[vars.zip(matches)]
+      else
+        {child_id: string}
+      end
+    end
+
+    class << self
+      def child_id(&block)
+        self.child_id_serializer = block
+      end
+
+      def has_siblings(*args)
+        if args.last.is_a?(Hash)
+          hash = args.pop.each_with_object({}) do |(sibling_name, object_type), hash|
+            hash[sibling_name] = object_type
+          end
+        else
+          hash = {}
+        end
+
+        args.each_with_object(hash) do |sibling_name|
+          object_type = sibling_name
+          hash[sibling_name] = object_type
+        end
+
+        self.siblings = hash
+      end
+    end
+
+    private
+
+    def has_child_id_serializer?
+      self.class.has_child_id_serializer?
+    end
+
+    def has_siblings?
+      self.class.has_siblings?
+    end
+  end
+end

data/lib/object_momma/child.rb

@@ -0,0 +1,126 @@
+module ObjectMomma
+  ACTUALIZE_STRATEGIES = [:create, :find, :find_or_create]
+
+  class Child
+    attr_accessor :child_id
+    attr_reader :actualize_strategy, :builder, :object_type
+    alias_method :to_s, :child_id
+
+    def initialize(object_type, hash, actualize_strategy)
+      unless ACTUALIZE_STRATEGIES.include?(actualize_strategy)
+        raise ArgumentError, "Invalid actualize strategy "\
+          "`#{actualize_strategy}'; valid values are "\
+          "#{ACTUALIZE_STRATEGIES.map(&:to_s).join(', ')}"
+      end
+
+      @actualize_strategy = actualize_strategy
+      @builder            = ObjectMomma.builder_for(object_type).new(self)
+      @object_type        = object_type
+
+      builder.build_child_from_hash(hash) do |sibling_object_type, sibling_id|
+        self.class.new(sibling_object_type, sibling_id, @actualize_strategy)
+      end
+    end
+
+    def child_object
+      @child_object ||= actualize_child_object
+    end
+
+    class << self
+      alias_method :original_new, :new
+
+      def new(object_type, string_or_hash, *args)
+        if string_or_hash.is_a?(String)
+          hash = Builder.string_to_hash(object_type, string_or_hash)
+        elsif string_or_hash.is_a?(Hash)
+          hash = string_or_hash
+        else
+          raise ArgumentError, "Must instantiate a Child with a String or a "\
+            "Hash, not a #{string_or_hash.class.name}"
+        end
+
+        original_new(object_type, hash, *args)
+      end
+    end
+
+  private
+
+    def actualize_child_object
+      object = builder.first_or_initialize
+
+      if object.respond_to?(:first_or_initialize)
+        object = object.first_or_initialize
+      end
+
+      if builder.is_persisted?(object)
+        if actualize_strategy == :create
+          raise ObjectMomma::ObjectExists, "Child `#{child_id}' created by "\
+            "`#{builder.class.name}' exists already"
+        end
+      else
+        if actualize_strategy == :find
+          raise ObjectMomma::ObjectNotFound, "Child `#{child_id}' created by "\
+            "`#{builder.class.name}' does not yet exist"
+        end
+
+        # arity of -2: def build(object, attrs = {})   (optional)
+        # arity of 2:  def build(object, attrs)        (required)
+        if [-2, 2].include?(builder.method(:build!).arity)
+          builder.build!(object, attributes_for_child)
+        else
+          builder.build!(object)
+        end
+
+        unless builder.is_persisted?(object)
+          raise ObjectMomma::NotPersisted, "Child `#{child_id}' was created "\
+            "by `#{builder.class.name}' but wasn't persisted"
+        end
+      end
+
+      if builder.respond_to?(:decorate!)
+        builder.decorate!(object)
+      end
+
+      object
+    end
+
+    def attributes_for_child
+      return {} unless ObjectMomma.use_serialized_attributes
+
+      # Pluralize
+      if object_type.to_s.chars.to_a.last == "s"
+        file_name = object_type
+      else
+        file_name = "#{object_type}s"
+      end
+
+      path = File.join(ObjectMomma.serialized_attributes_path, "#{file_name}.yml")
+
+      if File.size?(path)
+        File.open(path) do |yml_file|
+          attributes_by_child_id = YAML::load(yml_file)
+          return recursively_symbolize_hash(attributes_by_child_id.fetch(child_id, {}))
+        end
+      end
+
+      {}
+    end
+
+    def recursively_symbolize_hash(hash = {})
+      recurse = lambda { |in_hash|
+        {}.tap do |out_hash|
+          in_hash.each do |key, in_value|
+            out_value = in_value.is_a?(Hash) ? recurse.call(in_value) : in_value.dup
+            if key.respond_to?(:to_sym)
+              out_hash[key.to_sym] = out_value
+            else
+              out_hash[key] = out_value
+            end
+          end
+        end
+      }
+
+      recurse.call(hash)
+    end
+  end
+end

data/lib/object_momma/class_attributes.rb

@@ -0,0 +1,19 @@
+module ObjectMomma
+  module ClassAttributes
+    # See http://www.ruby-forum.com/topic/197051
+    def class_attribute(*attributes)
+      singleton_class.class_eval do
+        attr_accessor *attributes
+      end
+
+      @class_attributes ||= []
+      @class_attributes.concat(attributes)
+    end
+
+    def inherited(subclass)
+      @class_attributes.each do |attribute|
+        subclass.send("#{attribute}=", self.send(attribute))
+      end
+    end
+  end
+end

data/lib/object_momma/config.rb

@@ -0,0 +1,28 @@
+module ObjectMomma
+  module Config
+    def self.extended(base)
+      base.singleton_class.instance_eval do
+        attr_reader :builder_path
+        attr_reader :serialized_attributes_path, :use_serialized_attributes
+      end
+    end
+
+    def builder_path=(path)
+      unless path.nil? || File.directory?(path)
+        raise ArgumentError, "`#{path}' is not a valid directory"
+      end
+      @builder_path = path
+    end
+
+    def serialized_attributes_path=(path)
+      unless File.directory?(path)
+        raise ArgumentError, "`#{path}' is not a valid directory"
+      end
+      @serialized_attributes_path = path
+    end
+
+    def use_serialized_attributes=(true_or_false)
+      @use_serialized_attributes = true_or_false ? true : false
+    end
+  end
+end

data/lib/object_momma/module_methods.rb

@@ -0,0 +1,80 @@
+module ObjectMomma
+  module ModuleMethods
+    def builder_for(object_type)
+      ObjectMomma::Builder.builder_for(object_type)
+    end
+
+    def method_missing(method_name, *args, &block)
+      return super unless respond_to?(method_name)
+      return super if block_given?
+
+      object_type, actualize_strategy = object_type_and_actualize_strategy_from_method_name(method_name)
+      args.push(actualize_strategy)
+
+      child = ObjectMomma::Child.new(object_type, *args)
+      child.child_object
+    end
+
+    def mullet!
+      return false if Object.const_defined?(:ObjectMother)
+
+      object_mother = Class.new(BasicObject) do
+        def self.method_missing(*args)
+          ObjectMomma.send(*args)
+        end
+      end
+
+      Object.const_set(:ObjectMother, object_mother)
+      true
+    end
+
+    def object_type_and_actualize_strategy_from_method_name(method_name)
+      # Try ObjectMomma.user
+      begin
+        builder_for(method_name)
+        object_type = method_name.to_sym
+        return [object_type, :find_or_create]
+      rescue NameError
+      end
+
+      # Try ObjectMomma.spawn_user, ObjectMomma.find_user
+      public_method_name, object_type = [*method_name.to_s.match(/^(create|find|spawn)_(\w+)$/).to_a[1..-1]].compact.map(&:to_sym)
+      return nil if object_type.nil?
+
+      begin
+        builder_for(object_type)
+        if public_method_name == :spawn
+          actualize_strategy = :find_or_create
+        else
+          actualize_strategy = public_method_name
+        end
+        [object_type, actualize_strategy]
+      rescue NameError
+        nil
+      end
+    end
+    alias_method :parse_method_name, :object_type_and_actualize_strategy_from_method_name
+
+    def respond_to?(method_name, *args)
+      return true if super
+      parse_method_name(method_name).nil? ? false : true
+    end
+
+    def spawn(hash = {})
+      hash.each do |object_type, child_id_or_ids|
+        begin
+          builder_for(object_type)
+        rescue NameError => ne
+          singularized = object_type.to_s.chomp('s').to_sym
+          raise ne if singularized == object_type
+          
+          builder_for(singularized)
+          object_type = singularized
+        end
+        
+        child_ids = [*child_id_or_ids]
+        child_ids.each { |child_id| send("spawn_#{object_type}", child_id) }
+      end
+    end
+  end
+end

data/lib/object_momma/version.rb

@@ -0,0 +1,3 @@
+module ObjectMomma
+  VERSION = "0.9.0"
+end

data/lib/object_momma.rb

@@ -0,0 +1,21 @@
+require 'yaml'
+
+require 'object_momma/class_attributes'
+
+require 'object_momma/builder'
+require 'object_momma/config'
+require 'object_momma/child'
+require 'object_momma/module_methods'
+require 'object_momma/version'
+
+module ObjectMomma
+  BadChildIdentifier     = Class.new(StandardError)
+  BadSerializer          = Class.new(StandardError)
+  NotPersisted           = Class.new(StandardError)
+  ObjectExists           = Class.new(StandardError)
+  ObjectNotFound         = Class.new(StandardError)
+  SubclassNotImplemented = Class.new(StandardError)
+
+  self.extend(ObjectMomma::ModuleMethods)
+  self.extend(ObjectMomma::Config)
+end

data/object_momma.gemspec

@@ -0,0 +1,19 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/object_momma/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["ntl"]
+  gem.email         = ["nathanladd@gmail.com"]
+  gem.description   = %q{object_momma is an Object Mother implementation in ruby}
+  gem.summary       = %q{object_momma is an Object Mother implementation in ruby}
+  gem.homepage      = ""
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "object_momma"
+  gem.require_paths = ["lib"]
+  gem.version       = ObjectMomma::VERSION
+
+  gem.add_development_dependency 'rspec'
+end

data/spec/fixtures/blog_post_voting_classes.rb

@@ -0,0 +1,135 @@
+File.dirname(__FILE__).tap do |current_directory|
+  %w{fake_model post user comment vote}.each do |file|
+    require File.join(current_directory, file)
+  end
+end
+
+module ObjectMomma
+  class VoteBuilder < Builder
+    has_siblings :comment, :voter => :user
+    child_id { "#{voter}'s #{vote_type} for #{comment}" }
+
+    def first_or_initialize
+      Vote.where({
+        comment_id: comment.id,
+        user_id:    voter.id,
+        type:       vote_type.downcase
+      })
+    end
+
+    def decorate(vote)
+      # The regular Vote class doesn't implement this method, but Vote objects
+      # instantiated via ObjectMomma will get this behavior. Be careful with
+      # this feature, it can make a mess!
+      def vote.switch_vote!
+        if upvote?
+          self.type = 'downvote'
+        else
+          self.type = 'upvote'
+        end
+      end
+    end
+    
+    def build!(vote)
+      # This is demonstration only. In a real ActiveRecord scenario, that
+      # scope returned by #first_or_initialize would have set this stuff for
+      # us. It may be possible to automatically do this in a generic way.
+      vote.comment = self.comment
+      vote.type    = self.vote_type
+      vote.user    = self.voter
+
+      # This is basic "set my data according to who I am" logic:
+      if vote.user.politician?
+        vote.switch_vote!
+      end
+
+      vote.save!
+    end
+  end
+
+  class UserBuilder < Builder
+    def first_or_initialize
+      User.where(email: test_email)
+    end
+
+    def decorate!(user)
+      def user.politician?
+        full_name == "John Adams"
+      end
+    end
+
+    def build!(user, attributes = {})
+      # ActiveRecord's scope returned by #first_or_initialize would do this for
+      # us under normal circumstances.
+      user.email     = attributes[:email]    || test_email
+      user.username  = attributes[:username] || test_username
+      user.full_name = child_id
+
+      user.save!
+    end
+
+  private
+
+    # A child id of 'Scott Pilgrim' becomes 'scottpilgrim@zz.zzz'
+    def test_email
+      "#{test_username}@zz.zzz"
+    end
+
+    # A child id of 'Scott Pilgrim' becomes 'scottpilgrim'
+    def test_username
+      self.child_id.split(' ', 2).map(&:downcase).join
+    end
+  end
+
+  class PostBuilder < Builder
+    child_id { "Post about #{subject}" }
+
+    def first_or_initialize
+      Post.where(title: title_from_subject)
+    end
+
+    def build!(post)
+      post.title   = title_from_subject
+      post.subject = self.subject
+      post.body    = body_from_subject
+
+      post.save!
+    end
+
+  private
+
+    def body_from_subject
+      case self.subject
+      when "Comic Books" then "Batman is the best comic book of all time"
+      when "Politics" then "John Adams was a great leader."
+      else "Lorem Ipsum"
+      end
+    end
+
+    def title_from_subject
+      case self.subject
+      when "Comic Books" then "Batman"
+      else "My Thoughts on #{self.subject}"
+      end
+    end
+  end
+
+  class CommentBuilder < Builder
+    has_siblings :post, :author => :user
+    child_id { "#{author}'s Comment on #{post}" }
+
+    def first_or_initialize
+      Comment.where({
+        post_id: post.id,
+        user_id: author.id
+      })
+    end
+
+    def build!(comment)
+      comment.post = self.post
+      comment.user = self.author
+
+      comment.save!
+    end
+  end
+end

data/spec/fixtures/comment.rb

@@ -0,0 +1,8 @@
+class Comment
+  include FakeModel
+
+  belongs_to :post
+  belongs_to :user
+
+  fake_column :text
+end

data/spec/fixtures/fake_model.rb

@@ -0,0 +1,90 @@
+module FakeModel
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+
+  def ==(other_object)
+    self.object_id == other_object.object_id
+  end
+
+  def initialize(attributes = {})
+    attributes.each do |key, value|
+      instance_variable_set("@#{key}".to_sym, value)
+    end
+
+    self.class.instances << self
+  end
+  
+  def id
+    return nil unless persisted?
+
+    persisted_instances = self.class.instances.select(&:persisted?)
+    index = persisted_instances.index { |instance| instance == self }
+    index + 1
+  end
+
+  def persisted?
+    @is_persisted ? true : false
+  end
+
+  def save
+    @is_persisted = true
+    true
+  end
+  alias_method :save!, :save
+
+  module ClassMethods
+    def belongs_to(association_name)
+      define_method(association_name) do
+        instance_variable_get("@#{association_name}")
+      end
+
+      define_method("#{association_name}_id") do
+        send(association_name).id
+      end
+
+      define_method("#{association_name}=") do |value|
+        instance_variable_set("@#{association_name}", value)
+      end
+    end
+
+    def destroy_all
+      instances.clear
+    end
+
+    def instances
+      @instances ||= []
+    end
+
+    def fake_column(column_name)
+      class_eval { attr_accessor(column_name) }
+    end
+
+    def fake_columns(*column_names)
+      column_names.each { |column_name| fake_column(column_name) }
+    end
+
+    def where(conditions = {})
+      object = instances.detect do |object|
+        conditions.all? { |attr, value| object.send(attr) == value }
+      end
+
+      object ||= self.new
+
+      scope = BasicObject.new
+
+      scope.instance_exec(object) { |o| @__scope_object__ = o }
+
+      class << scope
+        def first_or_initialize
+          @__scope_object__
+        end
+        def method_missing(method_name, *args, &block)
+          @__scope_object__.send(method_name, *args, &block)
+        end
+      end
+
+      scope
+    end
+  end
+end

data/spec/fixtures/post.rb

@@ -0,0 +1,5 @@
+class Post
+  include FakeModel
+
+  fake_columns :body, :subject, :title
+end

data/spec/fixtures/thing_builder.rb

@@ -0,0 +1,18 @@
+class ObjectMomma::ThingBuilder < ObjectMomma::Builder
+  class Thing
+    attr_accessor :a_property, :another_property
+
+    def persisted?
+      a_property.nil? ? false : true
+    end
+  end
+
+  def first_or_initialize
+    Thing.new
+  end
+
+  def build!(thing)
+    thing.a_property       = :foo
+    thing.another_property = :bar
+  end
+end

data/spec/fixtures/user.rb

@@ -0,0 +1,5 @@
+class User
+  include FakeModel
+
+  fake_columns :email, :full_name, :username
+end

data/spec/fixtures/users.yml

@@ -0,0 +1,3 @@
+Scott Pilgrim:
+  email:    foobar@zz.zzz
+  username: lovemuscle23

data/spec/fixtures/vote.rb

@@ -0,0 +1,16 @@
+class Vote
+  include FakeModel
+
+  belongs_to :comment
+  belongs_to :user
+
+  fake_column :type
+
+  def downvote?
+    type == 'downvote'
+  end
+
+  def upvote?
+    type == 'upvote'
+  end
+end

data/spec/object_momma_spec.rb

@@ -0,0 +1,223 @@
+require 'object_momma'
+require File.join(File.dirname(__FILE__), 'fixtures/blog_post_voting_classes')
+
+describe ObjectMomma do
+  before do
+    User.destroy_all
+    Post.destroy_all
+    Comment.destroy_all
+    Vote.destroy_all
+  end
+
+  let(:vote_child_id) do
+    "Billy Pilgrim's Upvote for Scott Pilgrim's Comment on Post about Comic Books"
+  end
+
+  context "A simple object type (User)" do
+    shared_examples_for "Scott Pilgrim" do
+      it("is a User") { user.should be_a(User) }
+      it("has its' email set properly") { user.email.should == "scottpilgrim@zz.zzz" }
+      it("has its' username set properly") { user.username.should == "scottpilgrim" }
+      it("is persisted") { user ; ObjectMomma.find_user("Scott Pilgrim") }
+    end
+
+    context "when instantiated with a Hash" do
+      let(:user) { ObjectMomma.spawn_user(child_id: "Scott Pilgrim") }
+      it_behaves_like "Scott Pilgrim"
+    end
+
+    context "when instantiated with a String" do
+      let(:user) { ObjectMomma.spawn_user("Scott Pilgrim") }
+      it_behaves_like "Scott Pilgrim"
+    end
+  end
+
+  context "An object type that has a child id constructor (Post)" do
+    shared_examples_for "Post about Comic Books" do
+      it("is a Post") { post.should be_a(Post) }
+      it("has its' title set properly") { post.title.should == "Batman" }
+      it("has its' subject set properly") { post.subject.should == "Comic Books" }
+      it("is persisted") { post ; ObjectMomma.find_post("Post about Comic Books") }
+    end
+    
+    context "when instantiated with a Hash" do
+      let(:post) { ObjectMomma.spawn_post(subject: "Comic Books") }
+      it_behaves_like "Post about Comic Books"
+    end
+
+    context "when instantiated with a String" do
+      let(:post) { ObjectMomma.spawn_post("Post about Comic Books") }
+      it_behaves_like "Post about Comic Books"
+    end
+  end
+
+  context "An object with simple siblings (Comment)" do
+    shared_examples_for "Scott Pilgrim's Comment on Post about Comic Books" do
+      it("is a Comment") { comment.should be_a(Comment) }
+      it("has its' user set properly") do
+        comment.user.object_id.should == ObjectMomma.find_user("Scott Pilgrim").object_id
+      end
+      it("has its' post set properly") do
+        comment.post.object_id.should == ObjectMomma.find_post("Post about Comic Books").object_id
+      end
+      it("is persisted") do
+        comment
+        ObjectMomma.find_comment("Scott Pilgrim's Comment on Post about Comic Books")
+      end
+    end
+    
+    context "when instantiated with a Hash" do
+      let(:comment) do
+        ObjectMomma.spawn_comment({
+          author: "Scott Pilgrim",
+          post:   "Post about Comic Books"
+        })
+      end
+      it_behaves_like "Scott Pilgrim's Comment on Post about Comic Books"
+    end
+
+    context "when instantiated with a String" do
+      let(:comment) do
+        ObjectMomma.spawn_comment("Scott Pilgrim's Comment on Post about Comic Books")
+      end
+      it_behaves_like "Scott Pilgrim's Comment on Post about Comic Books"
+    end
+  end
+
+  context "An object with nested siblings (Vote)" do
+    context "when instantiated with a String" do
+      let(:vote) do
+        ObjectMomma.spawn_vote(vote_child_id)
+      end
+      it("is a Vote") { vote.should be_a(Vote) }
+      it("has its' user set properly") do
+        vote.user.object_id.should == ObjectMomma.find_user("Billy Pilgrim").object_id
+      end
+      it("has its' comment set properly") do
+        vote.comment.object_id.should == ObjectMomma.find_comment("Scott Pilgrim's Comment on Post about Comic Books").object_id
+      end
+    end
+  end
+
+  context "An object with serialized attributes" do
+    before do
+      ObjectMomma.use_serialized_attributes  = true
+      ObjectMomma.serialized_attributes_path = File.expand_path("../fixtures", __FILE__)
+    end
+
+    after do
+      ObjectMomma.use_serialized_attributes  = false
+    end
+
+    let(:user) { ObjectMomma.spawn_user("Scott Pilgrim") }
+
+    it "pulls in the attributes and loads them into the object" do
+      user.email.should    == "foobar@zz.zzz"
+      user.username.should == "lovemuscle23"
+    end
+  end
+
+  context "An object whose builder is stored in the builder path" do
+    after do
+      ObjectMomma.builder_path = nil
+    end
+
+    it "Loads the builder ruby file from the path only after builder path is set" do
+      lambda {
+        ObjectMomma.spawn_thing("The Thing")
+      }.should raise_error(NoMethodError)
+
+      ObjectMomma.builder_path = File.expand_path("../fixtures", __FILE__)
+
+      thing = ObjectMomma.spawn_thing("The Thing")
+
+      thing.a_property.should       == :foo
+      thing.another_property.should == :bar
+    end
+  end
+
+  context ".spawn" do
+    it "invokes #spawn_(object_type) for the supplied arguments" do
+      ObjectMomma.should_receive(:spawn_user).with("Billy Pilgrim").once
+      ObjectMomma.should_receive(:spawn_user).with("Scott Pilgrim").once
+      ObjectMomma.should_receive(:spawn_vote).with(vote_child_id).once
+      ObjectMomma.should_receive(:spawn_comment).with("Post about Politics").once
+
+      ObjectMomma.spawn({
+        users: ["Billy Pilgrim", "Scott Pilgrim"],
+        vote: vote_child_id,
+        comment: "Post about Politics"
+      })
+    end
+  end
+
+  context ".spawn_(object_type)" do
+    it "raises an ObjectMomma::BadChildIdentifier when it cannot parse child id" do
+      lambda {
+        ObjectMomma.spawn_post("Poast about Birds")
+      }.should raise_error(ObjectMomma::BadChildIdentifier)
+    end
+  end
+
+  context ".mullet!" do
+    before do
+      ObjectMomma.mullet!
+    end
+
+    after do
+      if Object.const_defined?(:ObjectMother)
+        Object.send(:remove_const, :ObjectMother)
+      end
+    end
+
+    it "defines ObjectMother" do
+      Object.const_defined?(:ObjectMother).should be_true
+    end
+
+    it "delegates everything to ObjectMomma" do
+      ObjectMomma.should_receive(:fizzle).with(:shizzle)
+      ObjectMother.fizzle(:shizzle)
+    end
+  end
+
+  context ".find_(object_type)" do
+    it "raises an ObjectMomma::ObjectNotFound exception when object does not exist" do
+      lambda {
+        ObjectMomma.find_user("Scott Pilgrim")
+      }.should raise_error(ObjectMomma::ObjectNotFound)
+    end
+
+    it "does not raise an ObjectMomma::ObjectNotFound exception when object does exist" do
+      ObjectMomma.spawn_user("Scott Pilgrim")
+      lambda {
+        ObjectMomma.find_user("Scott Pilgrim")
+      }.should_not raise_error(ObjectMomma::ObjectNotFound)
+    end
+  end
+
+  context ".create_(object_type)" do
+    it "does not raise an ObjectMomma::ObjectExists exception when object does not exist" do
+      lambda {
+        ObjectMomma.create_user("Scott Pilgrim")
+      }.should_not raise_error(ObjectMomma::ObjectExists)
+    end
+
+    it "raises an ObjectMomma::ObjectExists exception when object does exist" do
+      ObjectMomma.spawn_user("Scott Pilgrim")
+      lambda {
+        ObjectMomma.create_user("Scott Pilgrim")
+      }.should raise_error(ObjectMomma::ObjectExists)
+    end
+  end
+
+  context ".(object_type)" do
+    it "creates objects that don't exist, and finds objects that do" do
+      lambda {
+        ObjectMomma.user("Scott Pilgrim")
+      }.should_not raise_error(ObjectMomma::ObjectNotFound)
+      lambda {
+        ObjectMomma.user("Scott Pilgrim")
+      }.should_not raise_error(ObjectMomma::ObjectExists)
+    end
+  end
+end

metadata

@@ -0,0 +1,104 @@
+--- !ruby/object:Gem::Specification 
+name: object_momma
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 9
+  - 0
+  version: 0.9.0
+platform: ruby
+authors: 
+- ntl
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-11-28 00:00:00 -06:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id001
+description: object_momma is an Object Mother implementation in ruby
+email: 
+- nathanladd@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/object_momma.rb
+- lib/object_momma/builder.rb
+- lib/object_momma/child.rb
+- lib/object_momma/class_attributes.rb
+- lib/object_momma/config.rb
+- lib/object_momma/module_methods.rb
+- lib/object_momma/version.rb
+- object_momma.gemspec
+- spec/fixtures/blog_post_voting_classes.rb
+- spec/fixtures/comment.rb
+- spec/fixtures/fake_model.rb
+- spec/fixtures/post.rb
+- spec/fixtures/thing_builder.rb
+- spec/fixtures/user.rb
+- spec/fixtures/users.yml
+- spec/fixtures/vote.rb
+- spec/object_momma_spec.rb
+- tmp/.gitkeep
+has_rdoc: true
+homepage: ""
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: object_momma is an Object Mother implementation in ruby
+test_files: 
+- spec/fixtures/blog_post_voting_classes.rb
+- spec/fixtures/comment.rb
+- spec/fixtures/fake_model.rb
+- spec/fixtures/post.rb
+- spec/fixtures/thing_builder.rb
+- spec/fixtures/user.rb
+- spec/fixtures/users.yml
+- spec/fixtures/vote.rb
+- spec/object_momma_spec.rb