object-daddy 1.0.0

data/lib/object_daddy.rb

@@ -0,0 +1,266 @@
+module ObjectDaddy
+
+  def self.included(klass)
+    klass.extend ClassMethods
+    if defined? ActiveRecord and klass < ActiveRecord::Base
+      klass.extend RailsClassMethods
+
+      class << klass
+        alias_method :validates_presence_of_without_object_daddy, :validates_presence_of
+        alias_method :validates_presence_of, :validates_presence_of_with_object_daddy
+        alias_method :validates_without_object_daddy, :validates
+        alias_method :validates, :validates_with_object_daddy
+      end
+    end
+  end
+
+  module ClassMethods
+    attr_accessor :exemplars_generated, :exemplar_path, :generators
+    attr_reader :presence_validated_attributes
+    protected :exemplars_generated=
+
+    # :call-seq:
+    #   spawn()
+    #   spawn() do |obj| ... end
+    #   spawn(args)
+    #   spawn(args) do |obj| ... end
+    #
+    # Creates a valid instance of this class, using any known generators. The
+    # generated instance is yielded to a block if provided.
+    def spawn(args = {})
+      gather_exemplars
+      if @concrete_subclass_name
+        return block_given? \
+          ? const_get(@concrete_subclass_name).spawn(args) {|instance| yield instance} \
+          : const_get(@concrete_subclass_name).spawn(args)
+      end
+      generate_values(args)
+      instance = new
+      args.each_pair do |attribute, value|
+        instance.send("#{attribute}=", value)  # support setting of mass-assignment protected attributes
+      end
+      yield instance if block_given?
+      instance
+    end
+
+    # register a generator for an attribute of this class
+    # generator_for :foo do |prev| ... end
+    # generator_for :foo do ... end
+    # generator_for :foo, value
+    # generator_for :foo => value
+    # generator_for :foo, :class => GeneratorClass
+    # generator_for :foo, :method => :method_name
+    def generator_for(handle, args = {}, &block)
+      if handle.is_a?(Hash)
+        raise ArgumentError, "only specify one attr => value pair at a time" unless handle.keys.length == 1
+        gen_data = handle
+        handle = gen_data.keys.first
+        args = gen_data[handle]
+      end
+
+      raise ArgumentError, "an attribute name must be specified" unless handle = handle.to_sym
+
+      unless args.is_a?(Hash)
+        unless block
+          retval = args
+          block = lambda { retval }  # lambda { args } results in returning the empty hash that args gets changed to
+        end
+        args = {}  # args is assumed to be a hash for the rest of the method
+      end
+
+      if args[:start]
+        block ||= lambda { |prev|  prev.succ }
+      end
+
+      if args[:method]
+        h = { :method => args[:method].to_sym }
+        h[:start] = args[:start] if args[:start]
+        record_generator_for(handle, h)
+      elsif args[:class]
+        raise ArgumentError, "generator class [#{args[:class].name}] does not have a :next method" unless args[:class].respond_to?(:next)
+        record_generator_for(handle, :class => args[:class])
+      elsif block
+        raise ArgumentError, "generator block must take an optional single argument" unless (-1..1).include?(block.arity)  # NOTE: lambda {} has an arity of -1, while lambda {||} has an arity of 0
+        h = { :block => block }
+        h[:start] = args[:start] if args[:start]
+        record_generator_for(handle, h)
+      else
+        raise ArgumentError, "a block, :class generator, :method generator, or value must be specified to generator_for"
+      end
+    end
+
+    def generates_subclass(subclass_name)
+      @concrete_subclass_name = subclass_name.to_s
+    end
+
+    def gather_exemplars
+      return if exemplars_generated
+
+      self.generators ||= {}
+      if superclass.respond_to?(:gather_exemplars)
+        superclass.gather_exemplars
+        self.generators = (superclass.generators).merge(generators).dup
+      end
+
+      exemplar_path.each do |raw_path|
+        path = File.join(raw_path, "#{underscore(name)}_exemplar.rb")
+        load(path) if File.exists?(path)
+      end
+
+      self.exemplars_generated = true
+    end
+
+    def presence_validated_attributes
+      @presence_validated_attributes ||= {}
+      attrs = @presence_validated_attributes
+      if superclass.respond_to?(:presence_validated_attributes)
+        attrs = superclass.presence_validated_attributes.merge(attrs)
+      end
+      attrs
+    end
+
+  protected
+
+    # we define an underscore helper ourselves since the ActiveSupport isn't available if we're not using Rails
+    def underscore(string)
+      string.gsub(/([a-z])([A-Z])/, '\1_\2').downcase
+    end
+
+    def record_generator_for(handle, generator)
+      self.generators ||= {}
+      raise ArgumentError, "a generator for attribute [:#{handle}] has already been specified" if (generators[handle] || {})[:source] == self
+      generators[handle] = { :generator => generator, :source => self }
+    end
+
+  private
+
+    def generate_values(args)
+      (generators || {}).each_pair do |handle, gen_data|
+        next if args.include?(handle) or args.include?(handle.to_s)
+
+        generator = gen_data[:generator]
+        if generator[:block]
+          process_generated_value(args, handle, generator, generator[:block])
+        elsif generator[:method]
+          method = method(generator[:method])
+          if method.arity == 1
+            process_generated_value(args, handle, generator, method)
+          else
+            args[handle] = method.call
+          end
+        elsif generator[:class]
+          args[handle] = generator[:class].next
+        end
+      end
+
+      generate_missing(args)
+    end
+
+    def process_generated_value(args, handle, generator, block)
+      if generator[:start]
+        value = generator[:start]
+        generator.delete(:start)
+      else
+        if block.arity == 0
+          value = block.call
+        else
+          value = block.call(generator[:prev])
+        end
+      end
+      generator[:prev] = args[handle] = value
+    end
+
+    def generate_missing(args)
+      if presence_validated_attributes and !presence_validated_attributes.empty?
+        req = {}
+        (presence_validated_attributes.keys - args.keys).each {|a| req[a.to_s] = true } # find attributes required by validates_presence_of not already set
+
+        belongs_to_associations = reflect_on_all_associations(:belongs_to).to_a
+        fk_method = Rails.version >= "3.1.0" ? :foreign_key : :primary_key_name
+        missing = belongs_to_associations.select { |a|  req[a.name.to_s] or req[a.send(fk_method).to_s] }
+        # Rails 3.1 compatibility jazz - current_scoped_methods was deprecated.
+        if scope = respond_to?(:current_scoped_methods) ? current_scoped_methods : current_scope
+          missing.reject! { |a| scope.scope_for_create.include?(a.send(fk_method)) }
+        end
+        missing.reject! { |a|  [a.name, a.send(fk_method)].any? { |n|  args.stringify_keys.include?(n.to_s) } }
+        missing.each {|a| args[a.name] = a.class_name.constantize.generate }
+      end
+    end
+  end
+
+  module RailsClassMethods
+    def exemplar_path
+      paths = ['spec', 'test'].inject([]) do |array, dir|
+        if File.directory?(File.join(Rails.root, dir))
+          array << File.join(Rails.root, dir, 'exemplars')
+        end
+        array
+      end
+    end
+
+    def validates_presence_of_with_object_daddy(*attr_names)
+      @presence_validated_attributes ||= {}
+      new_attr = attr_names.dup
+      new_attr.pop if new_attr.last.is_a?(Hash)
+      new_attr.each {|a| @presence_validated_attributes[a] = true }
+      validates_presence_of_without_object_daddy(*attr_names)
+    end
+
+    def validates_with_object_daddy(*args)
+      if args.last.is_a?(Hash) && args.last[:presence]
+        @presence_validated_attributes ||= {}
+        @presence_validated_attributes[args.first] = true
+      end
+      validates_without_object_daddy(*args)
+    end
+
+    # :call-seq:
+    #   generate()
+    #   generate() do |obj| ... end
+    #   generate(args)
+    #   generate(args) do |obj| ... end
+    #
+    # Creates and tries to save an instance of this class, using any known
+    # generators. The generated instance is yielded to a block if provided.
+    #
+    # This will not raise errors on a failed save. Use generate! if you
+    # want errors raised.
+    def generate(args = {})
+      spawn(args) do |instance|
+        instance.save
+        yield instance if block_given?
+      end
+    end
+
+    # :call-seq:
+    #   generate()
+    #   generate() do |obj| ... end
+    #   generate(args)
+    #   generate(args) do |obj| ... end
+    #
+    # Creates and tries to save! an instance of this class, using any known
+    # generators. The generated instance is yielded to a block if provided.
+    #
+    # This will raise errors on a failed save. Use generate if you do not want
+    # errors raised.
+    def generate!(args = {})
+      spawn(args) do |instance|
+        instance.save!
+        yield instance if block_given?
+      end
+    end
+  end
+end
+
+unless ActiveRecord::Base.respond_to? :inherited_with_object_daddy
+  class ActiveRecord::Base
+    def self.inherited_with_object_daddy(subclass)
+      self.inherited_without_object_daddy(subclass)
+      subclass.send(:include, ObjectDaddy) unless subclass < ObjectDaddy
+    end
+
+    class << self
+      alias_method_chain :inherited, :object_daddy
+    end
+  end
+end

data/object-daddy.gemspec

@@ -0,0 +1,83 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = "object-daddy"
+  s.version = "1.0.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Rick Bradley", "Yossef Mendelssohn", "Jeremy Holland"]
+  s.date = "2012-04-07"
+  s.description = "Object Daddy is a library (as well as a Ruby on Rails plugin) designed to assist in automating testing of large collections of objects, especially webs of ActiveRecord models. It is a descendent of the \"Object Mother\" pattern for creating objects for testing, and is related to the concept of an \"object exemplar\" or stereotype."
+  s.email = ["blogicx@rickbradley.com", "ymendel@pobox.com", "jeremy@jeremypholland.com"]
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.markdown"
+  ]
+  s.files = [
+    ".rspec",
+    "Gemfile",
+    "Gemfile.lock",
+    "LICENSE.txt",
+    "README.markdown",
+    "Rakefile",
+    "VERSION",
+    "lib/generators/object_daddy_generator.rb",
+    "lib/object-daddy.rb",
+    "lib/object_daddy.rb",
+    "lib/object_daddy/railtie.rb",
+    "object-daddy.gemspec",
+    "spec/generators/object_daddy_generator_spec.rb",
+    "spec/object_daddy_spec.rb",
+    "spec/resources/schema",
+    "spec/spec_helper.rb",
+    "spec/tmp/.git_sucks"
+  ]
+  s.homepage = "http://github.com/awebneck/object_daddy"
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = "1.8.15"
+  s.summary = "Kill Fixtures"
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<rspec>, ["~> 2.8.0"])
+      s.add_development_dependency(%q<rdoc>, ["~> 3.12"])
+      s.add_development_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.8.3"])
+      s.add_development_dependency(%q<rails>, ["~> 3.1.4"])
+      s.add_development_dependency(%q<generator_spec>, [">= 0"])
+      s.add_development_dependency(%q<sqlite3>, [">= 0"])
+      s.add_development_dependency(%q<rspec-rails>, [">= 0"])
+      s.add_development_dependency(%q<pry>, [">= 0"])
+      s.add_development_dependency(%q<mocha>, [">= 0"])
+    else
+      s.add_dependency(%q<rspec>, ["~> 2.8.0"])
+      s.add_dependency(%q<rdoc>, ["~> 3.12"])
+      s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_dependency(%q<jeweler>, ["~> 1.8.3"])
+      s.add_dependency(%q<rails>, ["~> 3.1.4"])
+      s.add_dependency(%q<generator_spec>, [">= 0"])
+      s.add_dependency(%q<sqlite3>, [">= 0"])
+      s.add_dependency(%q<rspec-rails>, [">= 0"])
+      s.add_dependency(%q<pry>, [">= 0"])
+      s.add_dependency(%q<mocha>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<rspec>, ["~> 2.8.0"])
+    s.add_dependency(%q<rdoc>, ["~> 3.12"])
+    s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+    s.add_dependency(%q<jeweler>, ["~> 1.8.3"])
+    s.add_dependency(%q<rails>, ["~> 3.1.4"])
+    s.add_dependency(%q<generator_spec>, [">= 0"])
+    s.add_dependency(%q<sqlite3>, [">= 0"])
+    s.add_dependency(%q<rspec-rails>, [">= 0"])
+    s.add_dependency(%q<pry>, [">= 0"])
+    s.add_dependency(%q<mocha>, [">= 0"])
+  end
+end
+

data/spec/generators/object_daddy_generator_spec.rb

@@ -0,0 +1,124 @@
+require 'spec_helper'
+require 'generators/object_daddy_generator'
+require 'generator_spec/test_case'
+
+describe ObjectDaddyGenerator do
+  include GeneratorSpec::TestCase
+  destination File.expand_path("../../tmp/generator/", __FILE__)
+
+  before(:all) do
+    prepare_destination
+  end
+
+  describe 'when there is a spec directory under RAILS_ROOT' do
+    before :each do
+      FileUtils.mkdir "#{destination_root}/spec"
+    end
+
+    describe 'and there is a spec/exemplars directory under RAILS_ROOT' do
+      before :each do
+        FileUtils.mkdir "#{destination_root}/spec/exemplars"
+      end
+
+      it 'should not create any new directories' do
+        FileUtils.touch "#{destination_root}/spec/exemplars/test_exemplar.rb"
+        run_generator
+        destination_root.should have_structure {
+          directory "spec" do
+            directory "exemplars" do
+              file "test_exemplar.rb"
+            end
+          end
+        }
+      end
+
+      after :each do
+        FileUtils.rm_rf "#{destination_root}/spec/exemplars"
+      end
+    end
+
+    describe 'but there is no spec/exemplars directory under RAILS_ROOT' do
+      it 'should create a spec/exemplars directory under RAILS_ROOT' do
+        run_generator
+        destination_root.should have_structure {
+          directory "spec" do
+            directory "exemplars" do
+              file ".gitkeep"
+            end
+          end
+        }
+      end
+    end
+
+    after :each do
+      FileUtils.rm_rf "#{destination_root}/spec"
+    end
+  end
+
+  describe 'when there is no spec directory under RAILS_ROOT' do
+    describe 'and there is a test directory under RAILS_ROOT' do
+      before :each do
+        FileUtils.mkdir "#{destination_root}/test"
+      end
+
+      describe 'and there is a test/exemplars directory under RAILS_ROOT' do
+        before :each do
+          FileUtils.mkdir "#{destination_root}/test/exemplars"
+        end
+
+        it 'should not create any new directories' do
+          FileUtils.touch "#{destination_root}/test/exemplars/test_exemplar.rb"
+          run_generator
+          destination_root.should have_structure {
+            directory "test" do
+              directory "exemplars" do
+                file "test_exemplar.rb"
+              end
+            end
+          }
+        end
+
+        after :each do
+          FileUtils.rm_rf "#{destination_root}/test/exemplars"
+        end
+      end
+
+      describe 'but there is no test/exemplars directory under RAILS_ROOT' do
+        it 'should create a test/exemplars directory under RAILS_ROOT' do
+          run_generator
+          destination_root.should have_structure {
+            directory "test" do
+              directory "exemplars" do
+                file ".gitkeep"
+              end
+            end
+          }
+        end
+      end
+
+      after :each do
+        FileUtils.rm_rf "#{destination_root}/test"
+      end
+    end
+
+    describe 'and there is no test directory under RAILS_ROOT' do
+      it 'should create a spec directory under RAILS_ROOT' do
+        run_generator
+        destination_root.should have_structure {
+          directory "spec"
+        }
+      end
+
+      it 'should create a spec/exemplars directory under RAILS_ROOT' do
+        run_generator
+        destination_root.should have_structure {
+          directory "spec" do
+            directory "exemplars" do
+              file ".gitkeep"
+            end
+          end
+        }
+      end
+    end
+  end
+end