fabrication 1.4.1 → 2.0.0

data/lib/fabrication.rb

@@ -1,5 +1,4 @@
 module Fabrication
-
   autoload :DuplicateFabricatorError, 'fabrication/errors/duplicate_fabricator_error'
   autoload :UnfabricatableError,      'fabrication/errors/unfabricatable_error'
   autoload :UnknownFabricatorError,   'fabrication/errors/unknown_fabricator_error'
@@ -17,9 +16,7 @@ module Fabrication
   autoload :Support,    'fabrication/support'
   autoload :Transform,  'fabrication/transform'
 
-  module Cucumber
-    autoload :StepFabricator, 'fabrication/cucumber/step_fabricator'
-  end
+  autoload :Cucumber, 'fabrication/cucumber/step_fabricator'
 
   module Generator
     autoload :ActiveRecord, 'fabrication/generator/active_record'
@@ -38,18 +35,9 @@ module Fabrication
     Fabrication::Config.configure(&block)
   end
 
-  def self.initializing=(value)
-    @initializing = value
-  end
-
-  def self.initializing?
-    @initializing
-  end
-
   def self.schematics
     @schematics ||= Fabrication::Schematic::Manager.new
   end
-
 end
 
 def Fabricator(name, options={}, &block)
@@ -57,30 +45,26 @@ def Fabricator(name, options={}, &block)
 end
 
 def Fabricate(name, overrides={}, &block)
-  raise Fabrication::MisplacedFabricateError.new(name) if Fabrication.initializing?
-  Fabrication::Fabricator.generate(name, {
-    :save => true
-  }, overrides, &block)
+  raise Fabrication::MisplacedFabricateError.new(name) if Fabrication.schematics.initializing?
+  Fabrication::Fabricator.fabricate(name, overrides, &block).tap do |object|
+    Fabrication::Cucumber::Fabrications[name] = object if Fabrication::Config.register_with_steps?
+  end
 end
 
 class Fabricate
-
-  def self.attributes_for(name, options={}, &block)
-    Fabrication::Fabricator.generate(name, {
-      :save => false, :attributes => true
-    }, options, &block)
+  def self.attributes_for(name, overrides={}, &block)
+    Fabrication::Fabricator.to_attributes(name, overrides, &block)
   end
 
-  def self.build(name, options={}, &block)
-    Fabrication::Fabricator.generate(name, {
-      :save => false
-    }, options, &block)
+  def self.build(name, overrides={}, &block)
+    Fabrication::Fabricator.build(name, overrides, &block).tap do |object|
+      Fabrication::Cucumber::Fabrications[name] = object if Fabrication::Config.register_with_steps?
+    end
   end
 
   def self.sequence(name=Fabrication::Sequencer::DEFAULT, start=0, &block)
     Fabrication::Sequencer.sequence(name, start, &block)
   end
-
 end
 
 module FabricationMethods

data/lib/fabrication/config.rb

@@ -6,23 +6,38 @@ module Fabrication
       yield self
     end
 
-    def fabricator_dir
-      OPTIONS[:fabricator_dir]
+    def fabricator_path
+      OPTIONS[:fabricator_path]
     end
+    alias fabricator_dir fabricator_path
 
-    def fabricator_dir=(folders)
-      OPTIONS[:fabricator_dir] = (Array.new << folders).flatten
+    def fabricator_path=(folders)
+      OPTIONS[:fabricator_path] = (Array.new << folders).flatten
     end
+    alias fabricator_dir= fabricator_path=
 
     def reset_defaults
       OPTIONS.clear
       OPTIONS.merge!(DEFAULTS)
     end
 
+    def active_support?
+      @active_support ||= defined?(ActiveSupport)
+    end
+
+    def register_with_steps?
+      OPTIONS[:register_with_steps]
+    end
+
+    def register_with_steps=(register)
+      OPTIONS[:register_with_steps] = register
+    end
+
     private
 
     DEFAULTS = {
-      :fabricator_dir => ['test/fabricators', 'spec/fabricators']
+      fabricator_path: ['test/fabricators', 'spec/fabricators'],
+      register_with_steps: false
     }
     OPTIONS = {}.merge!(DEFAULTS)
   end

data/lib/fabrication/cucumber/step_fabricator.rb

@@ -54,7 +54,9 @@ module Fabrication
       end
 
       def schematic
-        Fabrication.schematics[@fabricator]
+        Fabrication.schematics[@fabricator].tap do |schematic|
+          raise Fabrication::UnknownFabricatorError, "No Fabricator defined for '#{@model}'" unless schematic
+        end
       end
 
       def dehumanize(string)

data/lib/fabrication/fabricator.rb

@@ -1,10 +1,24 @@
 class Fabrication::Fabricator
 
-  def self.generate(name, options={}, overrides={}, &block)
+  def self.build(name, overrides={}, &block)
+    schematic(name).build(overrides, &block)
+  end
+
+  def self.fabricate(name, overrides={}, &block)
+    schematic(name).fabricate(overrides, &block)
+  end
+
+  def self.to_attributes(name, overrides={}, &block)
+    schematic(name).to_attributes(overrides, &block)
+  end
+
+  private
+
+  def self.schematic(name)
     Fabrication::Support.find_definitions if Fabrication.schematics.empty?
-    schematic = Fabrication.schematics[name]
-    raise Fabrication::UnknownFabricatorError, "No Fabricator defined for '#{name}'" unless schematic
-    schematic.generate(options, overrides, &block)
+    Fabrication.schematics[name].tap do |schematic|
+      raise Fabrication::UnknownFabricatorError, "No Fabricator defined for '#{name}'" unless schematic
+    end
   end
 
 end

data/lib/fabrication/generator/active_record.rb

@@ -4,12 +4,8 @@ class Fabrication::Generator::ActiveRecord < Fabrication::Generator::Base
     defined?(ActiveRecord) && klass.ancestors.include?(ActiveRecord::Base)
   end
 
-  def associations
-    @associations ||= __klass.reflections.keys
-  end
-
-  def association?(method_name)
-    associations.include?(method_name.to_sym)
+  def build_instance
+    self.__instance = __klass.new(__attributes)
   end
 
 end

data/lib/fabrication/generator/base.rb

@@ -2,59 +2,61 @@ class Fabrication::Generator::Base
 
   def self.supports?(__klass); true end
 
-  def generate(options={:save => true}, attributes=[], callbacks={})
+  def build(attributes=[], callbacks={})
+    process_attributes(attributes)
+
     if callbacks[:on_init]
-      self.__instance = __klass.new(*callbacks[:on_init].call)
+      build_instance_with_init_callback(callbacks[:on_init])
     else
-      self.__instance = __klass.new
+      build_instance
     end
 
-    process_attributes(attributes)
-
     callbacks[:after_build].each { |callback| callback.call(__instance) } if callbacks[:after_build]
-    after_generation(options)
-    callbacks[:after_create].each { |callback| callback.call(__instance) } if callbacks[:after_create] && options[:save]
 
     __instance
   end
 
+  def create(attributes=[], callbacks=[])
+    build(attributes, callbacks)
+    persist
+    callbacks[:after_create].each { |callback| callback.call(__instance) } if callbacks[:after_create]
+    __instance
+  end
+
+  def to_hash(attributes=[], callbacks=[])
+    process_attributes(attributes)
+    (Fabrication::Config.active_support? ? HashWithIndifferentAccess.new : {}).tap do |hash|
+      __attributes.map do |name, value|
+        if value && value.respond_to?(:id)
+          hash["#{name}_id"] = value.id
+        else
+          hash[name] = value
+        end
+      end
+    end
+  end
+
+  def build_instance_with_init_callback(callback)
+    self.__instance = __klass.new(*callback.call)
+    __attributes.each do |k,v|
+      __instance.send("#{k}=", v)
+    end
+  end
+
+  def build_instance
+    self.__instance = __klass.new
+    __attributes.each do |k,v|
+      __instance.send("#{k}=", v)
+    end
+  end
+
   def initialize(klass)
     self.__klass = klass
   end
 
-  def association?(method_name); false end
-
   def method_missing(method_name, *args, &block)
     if block_given?
-      options = args.first || {}
-      if !options[:force] && association?(method_name)
-        method_name = method_name.to_s
-        count = options[:count] || 0
-
-        # copy the original getter
-        __instance.instance_variable_set("@__#{method_name}_original", __instance.method(method_name))
-
-        # store the block for lazy generation
-        __instance.instance_variable_set("@__#{method_name}_block", block)
-
-        # redefine the getter
-        __instance.instance_eval %<
-          def #{method_name}
-            original_value = @__#{method_name}_original.call
-            if @__#{method_name}_block
-              if #{count} \>= 1
-                original_value = #{method_name}= (1..#{count}).map { |i| @__#{method_name}_block.call(self, i) }
-              else
-                original_value = #{method_name}= @__#{method_name}_block.call(self)
-              end
-              @__#{method_name}_block = nil
-            end
-            original_value
-          end
-        >
-      else
-        assign(method_name, options, &block)
-      end
+      assign(method_name, args.first || {}, &block)
     else
       assign(method_name, {}, args.first)
     end
@@ -64,31 +66,48 @@ class Fabrication::Generator::Base
 
   attr_accessor :__klass, :__instance
 
-  def after_generation(options)
-    __instance.save! if options[:save] && __instance.respond_to?(:save!)
+  def __attributes
+    @__attributes ||= {}
+  end
+
+  def persist
+    __instance.save! if __instance.respond_to?(:save!)
   end
 
-  def assign(method_name, options, raw_value=nil)
+  def assign(method_name, options, value=nil, &block)
     if options.has_key?(:count)
-      value = (1..options[:count]).map do |i|
-        block_given? ? yield(__instance, i) : raw_value
-      end
+      assign_collection(method_name, options[:count], value, &block)
     else
-      value = block_given? ? yield(__instance) : raw_value
+      assign_field(method_name, value, &block)
     end
-    __instance.send("#{method_name}=", value)
+  end
+
+  def assign_field(field_name, value, &block)
+    __attributes[field_name] = block_given? ? yield(__attributes) : value
+  end
+
+  def assign_collection(field_name, count, value, &block)
+    __attributes[field_name] = block_given? ?
+      (1..count).map { |i| yield(__attributes, i) } :
+      value * count
   end
 
   def post_initialize; end
 
   def process_attributes(attributes)
     attributes.each do |attribute|
+      __transient_fields << attribute.name if attribute.transient?
       if Proc === attribute.value
         method_missing(attribute.name, attribute.params, &attribute.value)
       else
         method_missing(attribute.name, attribute.value)
       end
     end
+    __attributes.reject! { |k| __transient_fields.include?(k) }
+  end
+
+  def __transient_fields
+    @__transient_fields ||= []
   end
 
 end

data/lib/fabrication/generator/data_mapper.rb

@@ -1,14 +1,16 @@
 class Fabrication::Generator::DataMapper < Fabrication::Generator::Base
 
-  class << self
-    def supports?(klass)
-      defined?(DataMapper) && klass.ancestors.include?(DataMapper::Hook)
-    end
+  def self.supports?(klass)
+    defined?(DataMapper) && klass.ancestors.include?(DataMapper::Hook)
+  end
+
+  def build_instance
+    self.__instance = __klass.new(__attributes)
   end
 
   protected
 
-  def after_generation(options)
-    __instance.save if options[:save] && __instance.respond_to?(:save)
+  def persist
+    __instance.save
   end
 end

data/lib/fabrication/generator/mongoid.rb

@@ -1,21 +1,11 @@
 class Fabrication::Generator::Mongoid < Fabrication::Generator::Base
+
   def self.supports?(klass)
     defined?(Mongoid) && klass.ancestors.include?(Mongoid::Document)
   end
 
-  def assign(method_name, options, raw_value=nil)
-    if options.has_key?(:count)
-      value = (1..options[:count]).map do |i|
-        block_given? ? yield(__instance, i) : raw_value
-      end
-    else
-      value = block_given? ? yield(__instance) : raw_value
-    end
-
-    if Mongoid.allow_dynamic_fields && !__instance.respond_to?("#{method_name}=")
-      __instance[method_name] = value
-    else
-      __instance.send("#{method_name}=", value)
-    end
+  def build_instance
+    self.__instance = __klass.new(__attributes)
   end
+
 end

data/lib/fabrication/generator/sequel.rb

@@ -4,8 +4,12 @@ class Fabrication::Generator::Sequel < Fabrication::Generator::Base
     defined?(Sequel) && klass.ancestors.include?(Sequel::Model)
   end
 
-  def after_generation(options)
-    __instance.save if options[:save]
+  def build_instance
+    self.__instance = __klass.new(__attributes)
+  end
+
+  def persist
+    __instance.save
   end
 
 end

data/lib/fabrication/schematic/attribute.rb

@@ -2,10 +2,22 @@ class Fabrication::Schematic::Attribute
 
   attr_accessor :name, :params, :value
 
-  def initialize(name, params, value)
+  def initialize(name, value, params={}, &block)
     self.name = name
     self.params = params
-    self.value = value
+    self.value = value.nil? ? block : value
+  end
+
+  def params
+    @params ||= {}
+  end
+
+  def transient!
+    params[:transient] = true
+  end
+
+  def transient?
+    params[:transient]
   end
 
 end

data/lib/fabrication/schematic/definition.rb

@@ -8,10 +8,9 @@ class Fabrication::Schematic::Definition
     Fabrication::Generator::Base
   ]
 
-  attr_accessor :generator, :klass
+  attr_accessor :klass
   def initialize(klass, &block)
     self.klass = klass
-    self.generator = GENERATORS.detect { |gen| gen.supports?(klass) }
     instance_eval(&block) if block_given?
   end
 
@@ -29,8 +28,10 @@ class Fabrication::Schematic::Definition
     attributes.select { |a| a.name == name }.first
   end
 
-  def append_or_update_attribute(attribute)
+  def append_or_update_attribute(attribute_name, value, params={}, &block)
+    attribute = Fabrication::Schematic::Attribute.new(attribute_name, value, params, &block)
     if index = attributes.index { |a| a.name == attribute.name }
+      attribute.transient! if attributes[index].transient?
       attributes[index] = attribute
     else
       attributes << attribute
@@ -47,14 +48,30 @@ class Fabrication::Schematic::Definition
     @callbacks ||= {}
   end
 
-  def generate(options={}, overrides={}, &block)
-    new_schematic = merge(overrides, &block)
-    new_schematic.instance_eval do
-      if options[:attributes]
-        to_hash(generator.new(klass).generate({:save => false}, attributes, callbacks))
-      else
-        generator.new(klass).generate(options, attributes, callbacks)
+  def generator
+    @generator ||= GENERATORS.detect { |gen| gen.supports?(klass) }
+  end
+
+  def build(overrides={}, &block)
+    Fabrication.schematics.build_stack << self
+    merge(overrides, &block).instance_eval do
+      generator.new(klass).build(attributes, callbacks)
+    end.tap { Fabrication.schematics.build_stack.pop }
+  end
+
+  def fabricate(overrides={}, &block)
+    if Fabrication.schematics.build_stack.empty?
+      merge(overrides, &block).instance_eval do
+        generator.new(klass).create(attributes, callbacks)
       end
+    else
+      build(overrides, &block)
+    end
+  end
+
+  def to_attributes(overrides={}, &block)
+    merge(overrides, &block).instance_eval do
+      generator.new(klass).to_hash(attributes, callbacks)
     end
   end
 
@@ -72,40 +89,41 @@ class Fabrication::Schematic::Definition
   end
 
   def merge(overrides={}, &block)
+    return self unless overrides.any? or block_given?
     clone.tap do |schematic|
       schematic.instance_eval(&block) if block_given?
       overrides.each do |name, value|
-        schematic.append_or_update_attribute(Fabrication::Schematic::Attribute.new(name.to_sym, nil, value))
+        schematic.append_or_update_attribute(name.to_sym, value)
       end
     end
   end
 
   def method_missing(method_name, *args, &block)
-    method_name = parse_method_name(method_name, args)
-    if args.empty? or args.first.is_a?(Hash)
-      params = args.first || {}
-      value = block_given? ? block : generate_value(method_name, params)
-    else
-      params = {}
-      value = args.first
-    end
-
-    append_or_update_attribute(Fabrication::Schematic::Attribute.new(method_name, params, value))
+    method_name = parse_method_name(method_name)
+    params = args.extract_options!
+    value = args.first
+    block = generate_value(method_name, params) if args.empty? && !block_given?
+    append_or_update_attribute(method_name, value, params, &block)
   end
 
   def on_init(&block)
     callbacks[:on_init] = block
   end
 
-  def parse_method_name(method_name, args)
+  def parse_method_name(method_name)
     if method_name.to_s.end_with?("!")
+      warn("DEPRECATION WARNING: Using the \"!\" in Fabricators is no longer supported. Please remove all occurrances")
       method_name = method_name.to_s.chomp("!").to_sym
-      args[0] ||= {}
-      args[0][:force] = true
     end
     method_name
   end
 
+  def transient(*field_names)
+    field_names.each do |field_name|
+      append_or_update_attribute(field_name, nil, transient: true)
+    end
+  end
+
   def sequence(name=Fabrication::Sequencer::DEFAULT, start=0, &block)
     name = "#{self.klass.to_s.downcase.gsub(/::/, '_')}_#{name}"
     Fabrication::Sequencer.sequence(name, start, &block)
@@ -119,18 +137,4 @@ class Fabrication::Schematic::Definition
     params[:count] ||= 1 if !params[:count] && name != name.to_s
     Proc.new { Fabricate(params[:fabricator] || name.to_sym) }
   end
-
-  def to_hash(object)
-    (defined?(HashWithIndifferentAccess) ? HashWithIndifferentAccess.new : {}).tap do |hash|
-      attributes.map do |attribute|
-        value = object.send(attribute.name)
-        if value && value.respond_to?(:id)
-          hash["#{attribute.name}_id"] = value.id
-        else
-          hash[attribute.name] = value
-        end
-      end
-    end
-  end
-
 end

data/lib/fabrication/schematic/manager.rb

@@ -1,5 +1,16 @@
 class Fabrication::Schematic::Manager
 
+  def preinitialize
+    @initializing = true
+    clear
+  end
+
+  def initializing?; @initializing end
+
+  def freeze
+    @initializing = false
+  end
+
   def clear
     schematics.clear
   end
@@ -22,6 +33,10 @@ class Fabrication::Schematic::Manager
     @schematics ||= {}
   end
 
+  def build_stack
+    @build_stack ||= []
+  end
+
   protected
 
   def raise_if_registered(name)

data/lib/fabrication/support.rb

@@ -23,14 +23,14 @@ class Fabrication::Support
     end
 
     def find_definitions
-      Fabrication.initializing = true
+      Fabrication.schematics.preinitialize
       path_prefix = defined?(Rails) ? Rails.root : "."
       Fabrication::Config.fabricator_dir.each do |folder|
         Dir.glob(File.join(path_prefix, folder, '**', '*.rb')).sort.each do |file|
           load file
         end
       end
-      Fabrication.initializing = false
+      Fabrication.schematics.freeze
     end
 
   end

data/lib/fabrication/version.rb

@@ -1,3 +1,3 @@
 module Fabrication
-  VERSION = '1.4.1'
+  VERSION = '2.0.0'
 end

data/lib/rails/generators/fabrication/cucumber_steps/templates/fabrication_steps.rb

@@ -1,8 +1,13 @@
 World(FabricationMethods)
 
+Fabrication::Config.register_with_steps = true
+
 def with_ivars(fabricator)
   @they = yield fabricator
-  instance_variable_set("@#{fabricator.model}", @they)
+  model = @they.last.class.to_s.underscore
+  instance_variable_set("@#{model.pluralize}", @they)
+  instance_variable_set("@#{model.singularize}", @they.last)
+  Fabrication::Cucumber::Fabrications[model.singularize.gsub(/\W+/,'_').downcase] = @they.last
 end
 
 Given /^(\d+) ([^"]*)$/ do |count, model_name|

data/lib/rails/generators/fabrication/model/templates/fabricator.rb

@@ -1,4 +1,4 @@
-Fabricator(:<%= singular_name %>) do
+Fabricator(<%= class_name.match(/::/) ? "'#{class_name}'" : ":#{singular_name}" %>) do
 <% attributes.each do |attribute| -%>
   <%= attribute.name %> <%= attribute.default.inspect %>
 <% end -%>

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fabrication
 version: !ruby/object:Gem::Version
-  version: 1.4.1
+  version: 2.0.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-06-01 00:00:00.000000000 Z
+date: 2012-06-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
-  requirement: &70131616319860 !ruby/object:Gem::Requirement
+  requirement: &70125484404120 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70131616319860
+  version_requirements: *70125484404120
 - !ruby/object:Gem::Dependency
   name: bson_ext
-  requirement: &70131616319440 !ruby/object:Gem::Requirement
+  requirement: &70125484403700 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +32,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70131616319440
+  version_requirements: *70125484403700
 - !ruby/object:Gem::Dependency
   name: cucumber
-  requirement: &70131616319020 !ruby/object:Gem::Requirement
+  requirement: &70125484403280 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,10 +43,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70131616319020
+  version_requirements: *70125484403280
 - !ruby/object:Gem::Dependency
   name: sqlite3
-  requirement: &70131616318600 !ruby/object:Gem::Requirement
+  requirement: &70125484402860 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -54,10 +54,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70131616318600
+  version_requirements: *70125484402860
 - !ruby/object:Gem::Dependency
   name: dm-active_model
-  requirement: &70131616318180 !ruby/object:Gem::Requirement
+  requirement: &70125484402440 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -65,10 +65,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70131616318180
+  version_requirements: *70125484402440
 - !ruby/object:Gem::Dependency
   name: dm-core
-  requirement: &70131616317760 !ruby/object:Gem::Requirement
+  requirement: &70125484402020 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -76,10 +76,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70131616317760
+  version_requirements: *70125484402020
 - !ruby/object:Gem::Dependency
   name: dm-migrations
-  requirement: &70131616317340 !ruby/object:Gem::Requirement
+  requirement: &70125484401600 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -87,10 +87,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70131616317340
+  version_requirements: *70125484401600
 - !ruby/object:Gem::Dependency
   name: dm-sqlite-adapter
-  requirement: &70131616316920 !ruby/object:Gem::Requirement
+  requirement: &70125484401180 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -98,10 +98,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70131616316920
+  version_requirements: *70125484401180
 - !ruby/object:Gem::Dependency
   name: turnip
-  requirement: &70131615272400 !ruby/object:Gem::Requirement
+  requirement: &70125484400660 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -109,10 +109,10 @@ dependencies:
         version: '0.3'
   type: :development
   prerelease: false
-  version_requirements: *70131615272400
+  version_requirements: *70125484400660
 - !ruby/object:Gem::Dependency
   name: ffaker
-  requirement: &70131615269340 !ruby/object:Gem::Requirement
+  requirement: &70125484400240 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -120,10 +120,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70131615269340
+  version_requirements: *70125484400240
 - !ruby/object:Gem::Dependency
   name: mongoid
-  requirement: &70131615264260 !ruby/object:Gem::Requirement
+  requirement: &70125484399780 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -131,10 +131,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70131615264260
+  version_requirements: *70125484399780
 - !ruby/object:Gem::Dependency
   name: pry
-  requirement: &70131616346200 !ruby/object:Gem::Requirement
+  requirement: &70125484399360 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -142,10 +142,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70131616346200
+  version_requirements: *70125484399360
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &70131616345780 !ruby/object:Gem::Requirement
+  requirement: &70125484398940 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -153,10 +153,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70131616345780
+  version_requirements: *70125484398940
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &70131616345360 !ruby/object:Gem::Requirement
+  requirement: &70125484398520 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -164,10 +164,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70131616345360
+  version_requirements: *70125484398520
 - !ruby/object:Gem::Dependency
   name: sequel
-  requirement: &70131616344940 !ruby/object:Gem::Requirement
+  requirement: &70125484398100 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -175,9 +175,9 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70131616344940
+  version_requirements: *70125484398100
 description: Fabrication is an object generation framework for ActiveRecord, Mongoid,
-  and Sequel. It has a sensible syntax and lazily generates ActiveRecord associations!
+  DataMapper, Sequel, or any other Ruby object.
 email:
 - paul@hashrocket.com
 executables: []