fabrication 2.20.1 → 3.0.0.beta.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 64e503b6bd8387aba620486cb389b3b3a2694473
-  data.tar.gz: 434881b49d868391b548c364361526884ebc9e66
+SHA256:
+  metadata.gz: 20a02618a5107ba5850de6da2bd58ae428d33d8163ab3c71f9233574780998df
+  data.tar.gz: 33bac0b9d796da2d94adf3a8eb8940ff8766c36c9435429a03a1da0dd1efb8ad
 SHA512:
-  metadata.gz: 31dd79d6add115b0688035eec9cff3df7219fca66f88f92ab352d8cbc7214e1c83b2fefd5e70c6fdcaa567f076f12901881fc9cd60c3e084cbecca65e60792aa
-  data.tar.gz: bda40d311f7701e30f3c04e34a94f60a4ddf001c1510155fb5131d9bb680fc1dc25a42959d2d0b39252c3d60ab156d4c9099e0a47218d3de6a2978262f876977
+  metadata.gz: e0d2aa56f7153981b3be287dde1204a1050b964e5bdba14314d7f7cda4d7af7a4960cb2670bd2c58b7615768fdea84c4dbd15da2d1db95b5b4371e86091b336d
+  data.tar.gz: a182aecb4c3d38e36cd0e8f282dfd575b7234427a15e7f575cdbc84ca090848f162de9becc0989cef3baaa76c986a946c467b53adb937c5011932af774735b25

data/README.markdown

@@ -6,10 +6,7 @@ Fabrication is an object generation framework for Ruby.
 
 ## Compatibility
 
-Fabrication is tested against Ruby 2.2 and above.
-
-[![Build Status](https://secure.travis-ci.org/paulelliott/fabrication.png)](http://travis-ci.org/paulelliott/fabrication)
-[![Code Climate](https://codeclimate.com/github/paulelliott/fabrication.png)](https://codeclimate.com/github/paulelliott/fabrication)
+Fabrication is tested against all officially supported versions of Ruby.
 
 ## Documentation
 

data/Rakefile

@@ -1,20 +1,18 @@
-require "rubygems"
-require "bundler/setup"
+require 'rubygems'
+require 'bundler/setup'
 
 Bundler.require
 
-require "rspec/core/rake_task"
+require 'rspec/core/rake_task'
 RSpec::Core::RakeTask.new(:spec) do |spec|
-  spec.pattern = "spec/**/*_spec.rb"
+  spec.pattern = 'spec/**/*_spec.rb'
 end
 
 desc 'All cucumber features with kitchen sink appraisal'
 task :cucumber do
-  system('appraisal kitchen-sink cucumber -f progress')
+  system('appraisal kitchen-sink cucumber -f progress --publish-quiet')
 end
 
-if !ENV["APPRAISAL_INITIALIZED"] && !ENV["TRAVIS"]
-  task default: [:cucumber, :appraisal]
-else
-  task default: :spec
-end
+default_task = ENV['APPRAISAL_INITIALIZED'] ? :spec : %i[cucumber appraisal]
+
+task default: default_task

data/lib/fabricate.rb

@@ -1,51 +1,48 @@
 class Fabricate
-  def self.times(count, name, overrides={}, &block)
+  def self.times(count, name, overrides = {}, &block)
     count.times.map { Fabricate(name, overrides, &block) }
   end
 
-  def self.build_times(count, name, overrides={}, &block)
+  def self.build_times(count, name, overrides = {}, &block)
     count.times.map { Fabricate.build(name, overrides, &block) }
   end
 
-  def self.attributes_for_times(count, name, overrides={}, &block)
+  def self.attributes_for_times(count, name, overrides = {}, &block)
     count.times.map { Fabricate.attributes_for(name, overrides, &block) }
   end
 
-  def self.attributes_for(name, overrides={}, &block)
+  def self.attributes_for(name, overrides = {}, &block)
     fail_if_initializing(name)
     schematic(name).to_attributes(overrides, &block)
   end
 
-  def self.to_params(name, overrides={}, &block)
+  def self.to_params(name, overrides = {}, &block)
     fail_if_initializing(name)
     schematic(name).to_params(overrides, &block)
   end
 
-  def self.build(name, overrides={}, &block)
+  def self.build(name, overrides = {}, &block)
     fail_if_initializing(name)
     schematic(name).build(overrides, &block).tap do |object|
       Fabrication::Cucumber::Fabrications[name] = object if Fabrication::Config.register_with_steps?
     end
   end
 
-  def self.create(name, overrides={}, &block)
+  def self.create(name, overrides = {}, &block)
     fail_if_initializing(name)
     schematic(name).fabricate(overrides, &block)
   end
 
-  def self.sequence(name=Fabrication::Sequencer::DEFAULT, start=nil, &block)
+  def self.sequence(name = Fabrication::Sequencer::DEFAULT, start = nil, &block)
     Fabrication::Sequencer.sequence(name, start, &block)
   end
 
   def self.schematic(name)
     Fabrication.manager.load_definitions if Fabrication.manager.empty?
-    Fabrication.manager[name] || raise(Fabrication::UnknownFabricatorError.new(name))
+    Fabrication.manager[name] || raise(Fabrication::UnknownFabricatorError, name)
   end
 
-  private
-
   def self.fail_if_initializing(name)
-    raise Fabrication::MisplacedFabricateError.new(name) if Fabrication.manager.initializing?
+    raise Fabrication::MisplacedFabricateError, name if Fabrication.manager.initializing?
   end
-
 end

data/lib/fabrication.rb

@@ -32,7 +32,6 @@ module Fabrication
   module Generator
     autoload :ActiveRecord,  'fabrication/generator/active_record'
     autoload :ActiveRecord4, 'fabrication/generator/active_record_4'
-    autoload :DataMapper,    'fabrication/generator/data_mapper'
     autoload :Mongoid,       'fabrication/generator/mongoid'
     autoload :Sequel,        'fabrication/generator/sequel'
     autoload :Base,          'fabrication/generator/base'
@@ -52,20 +51,23 @@ module Fabrication
   end
 
   def self.schematics
-    puts "DEPRECATION WARNING: Fabrication.schematics has been replaced by Fabrication.manager and will be removed in 3.0.0."
+    puts 'DEPRECATION WARNING: Fabrication.schematics has been replaced by '\
+      'Fabrication.manager and will be removed in 3.0.0.'
     manager
   end
 end
 
-def Fabricator(name, options={}, &block)
+# rubocop:disable Naming/MethodName
+def Fabricator(name, options = {}, &block)
   Fabrication.manager.register(name, options, &block)
 end
 
-def Fabricate(name, overrides={}, &block)
+def Fabricate(name, overrides = {}, &block)
   Fabricate.create(name, overrides, &block).tap do |object|
     Fabrication::Cucumber::Fabrications[name] = object if Fabrication::Config.register_with_steps?
   end
 end
+# rubocop:enable Naming/MethodName
 
 module FabricationMethods
   def fabrications

data/lib/fabrication/config.rb

@@ -2,14 +2,16 @@ module Fabrication
   module Config
     extend self
 
-    def configure; yield self end
+    def configure
+      yield self
+    end
 
     def reset_defaults
       @fabricator_path =
         @path_prefix =
-        @sequence_start =
-        @generators =
-        nil
+          @sequence_start =
+            @generators =
+              nil
     end
 
     def fabricator_path
@@ -18,43 +20,54 @@ module Fabrication
     alias fabricator_paths fabricator_path
 
     def fabricator_dir
-      puts "DEPRECATION WARNING: Fabrication::Config.fabricator_dir has been replaced by Fabrication::Config.fabricator_path"
+      puts 'DEPRECATION WARNING: Fabrication::Config.fabricator_dir has been ' \
+        'replaced by Fabrication::Config.fabricator_path'
       fabricator_path
     end
 
     def fabricator_path=(folders)
-      @fabricator_path = (Array.new << folders).flatten
+      @fabricator_path = ([] << folders).flatten
     end
 
     def fabricator_dir=(folders)
-      puts "DEPRECATION WARNING: Fabrication::Config.fabricator_dir has been replaced by Fabrication::Config.fabricator_path"
+      puts 'DEPRECATION WARNING: Fabrication::Config.fabricator_dir has been ' \
+        'replaced by Fabrication::Config.fabricator_path'
       self.fabricator_path = folders
     end
 
-    attr_writer :sequence_start
-    def sequence_start; @sequence_start ||= 0 end
+    attr_writer :sequence_start, :register_with_steps
+
+    def sequence_start
+      @sequence_start ||= 0
+    end
 
     def path_prefix=(folders)
-      @path_prefix = (Array.new << folders).flatten
+      @path_prefix = ([] << folders).flatten
     end
 
     def path_prefix
-      @path_prefix ||= [defined?(Rails) ? Rails.root : "."]
+      @path_prefix ||= [defined?(Rails) ? Rails.root : '.']
     end
     alias path_prefixes path_prefix
 
-    attr_writer :register_with_steps
     def register_with_steps?
       @register_with_steps ||= nil
     end
 
-    def generators; @generators ||= [] end
+    def generators
+      @generators ||= []
+    end
 
     def generator_for(default_generators, klass)
       (generators + default_generators).detect { |gen| gen.supports?(klass) }
     end
 
-    def recursion_limit; @recursion_limit ||= 20 end
-    def recursion_limit=(limit); @recursion_limit = limit end
+    def recursion_limit
+      @recursion_limit ||= 20
+    end
+
+    def recursion_limit=(limit)
+      @recursion_limit = limit
+    end
   end
 end

data/lib/fabrication/cucumber/step_fabricator.rb

@@ -3,24 +3,27 @@ module Fabrication
     class StepFabricator
       attr_reader :model
 
-      def initialize(model_name, opts ={})
+      def initialize(model_name, opts = {})
         @model = dehumanize(model_name)
         @fabricator = Fabrication::Support.singularize(@model).to_sym
         @parent_name = opts.delete(:parent)
       end
 
-      def from_table(table, extra={})
+      def from_table(table, extra = {})
         hashes = singular? ? [table.rows_hash] : table.hashes
-        hashes.map do |hash|
+        transformed_hashes = hashes.map do |hash|
           transformed_hash = Fabrication::Transform.apply_to(@model, parameterize_hash(hash))
           make(transformed_hash.merge(extra))
-        end.tap {|o| remember(o) }
+        end
+        remember(transformed_hashes)
+        transformed_hashes
       end
 
-      def n(count, attrs={})
-        count.times.map { make(attrs) }.tap {|o| remember(o) }
+      def n(count, attrs = {})
+        count.times.map { make(attrs) }.tap { |o| remember(o) }
       end
 
+      # rubocop:disable Naming/PredicateName
       def has_many(children)
         instance = Fabrications[@fabricator]
         children = dehumanize(children)
@@ -29,9 +32,11 @@ module Fabrication
           child.respond_to?(:save!) && child.save!
         end
       end
+      # rubocop:enable Naming/PredicateName
 
       def parent
         return unless @parent_name
+
         Fabrications[dehumanize(@parent_name)]
       end
 
@@ -54,19 +59,20 @@ module Fabrication
       end
 
       def dehumanize(string)
-        string.gsub(/\W+/,'_').downcase
+        string.gsub(/\W+/, '_').downcase
       end
 
       def parameterize_hash(hash)
-        hash.inject({}) {|h,(k,v)| h.update(dehumanize(k).to_sym => v)}
+        hash.inject({}) { |h, (k, v)| h.update(dehumanize(k).to_sym => v) }
       end
 
-      def make(attrs={})
+      def make(attrs = {})
         Fabricate(@fabricator, attrs.merge(parentship))
       end
 
       def parentship
         return {} unless parent
+
         parent_class_name = parent.class.to_s.underscore
 
         parent_instance = parent
@@ -77,18 +83,19 @@ module Fabrication
 
         { parent_class_name => parent_instance }
       end
-
     end
 
     module Fabrications
-      @@fabrications = {}
+      def self.fabrications
+        @fabrications ||= {}
+      end
 
       def self.[](fabricator)
-        @@fabrications[fabricator.to_sym]
+        fabrications[fabricator.to_sym]
       end
 
       def self.[]=(fabricator, fabrication)
-        @@fabrications[fabricator.to_sym] = fabrication
+        fabrications[fabricator.to_sym] = fabrication
       end
     end
   end

data/lib/fabrication/errors/duplicate_fabricator_error.rb

@@ -1,5 +1,7 @@
-class Fabrication::DuplicateFabricatorError < StandardError
-  def initialize(string)
-    super("'#{string}' is already defined")
+module Fabrication
+  class DuplicateFabricatorError < StandardError
+    def initialize(string)
+      super("'#{string}' is already defined")
+    end
   end
 end

data/lib/fabrication/errors/infinite_recursion_error.rb

@@ -1,5 +1,7 @@
-class Fabrication::InfiniteRecursionError < StandardError
-  def initialize(name)
-    super("You appear to have infinite recursion with the `#{name}` fabricator")
+module Fabrication
+  class InfiniteRecursionError < StandardError
+    def initialize(name)
+      super("You appear to have infinite recursion with the `#{name}` fabricator")
+    end
   end
 end

data/lib/fabrication/errors/misplaced_fabricate_error.rb

@@ -1,5 +1,9 @@
-class Fabrication::MisplacedFabricateError < StandardError
-  def initialize(name)
-    super("You tried to fabricate `#{name}` while Fabricators were still loading. Check your fabricator files and make sure you didn't accidentally type `Fabricate` instead of `Fabricator` in there somewhere.")
+module Fabrication
+  class MisplacedFabricateError < StandardError
+    def initialize(name)
+      super("You tried to fabricate `#{name}` while Fabricators were still loading. " \
+            "Check your fabricator files and make sure you didn't accidentally type " \
+            '`Fabricate` instead of `Fabricator` in there somewhere.')
+    end
   end
 end

data/lib/fabrication/errors/unfabricatable_error.rb

@@ -1,6 +1,7 @@
-class Fabrication::UnfabricatableError < StandardError
-
-  def initialize(name, original_error)
-    super("No class found for '#{name}' (original exception: #{original_error.message})")
+module Fabrication
+  class UnfabricatableError < StandardError
+    def initialize(name, original_error)
+      super("No class found for '#{name}' (original exception: #{original_error.message})")
+    end
   end
 end

data/lib/fabrication/errors/unknown_fabricator_error.rb

@@ -1,7 +1,7 @@
-class Fabrication::UnknownFabricatorError < StandardError
-
-  def initialize(name)
-    super("No Fabricator defined for '#{name}'")
+module Fabrication
+  class UnknownFabricatorError < StandardError
+    def initialize(name)
+      super("No Fabricator defined for '#{name}'")
+    end
   end
-
 end

data/lib/fabrication/generator/active_record.rb

@@ -1,15 +1,22 @@
-class Fabrication::Generator::ActiveRecord < Fabrication::Generator::Base
+module Fabrication
+  module Generator
+    class ActiveRecord < Fabrication::Generator::Base
+      def self.supports?(klass)
+        # Some gems will declare an ActiveRecord module for their own purposes
+        # so we can't assume because we have the ActiveRecord module that we also
+        # have ActiveRecord::Base. Because defined? can return nil we ensure that nil
+        # becomes false.
+        defined?(::ActiveRecord) && defined?(::ActiveRecord::Base) &&
+          klass.ancestors.include?(::ActiveRecord::Base) || false
+      end
 
-  def self.supports?(klass)
-    defined?(ActiveRecord) && klass.ancestors.include?(ActiveRecord::Base)
-  end
-
-  def build_instance
-    if _klass.respond_to?(:protected_attributes)
-      self._instance = _klass.new(_attributes, without_protection: true)
-    else
-      self._instance = _klass.new(_attributes)
+      def build_instance
+        self._instance = if _klass.respond_to?(:protected_attributes)
+                           _klass.new(_attributes, without_protection: true)
+                         else
+                           _klass.new(_attributes)
+                         end
+      end
     end
   end
-
 end

data/lib/fabrication/generator/base.rb

@@ -1,103 +1,111 @@
-class Fabrication::Generator::Base
-
-  def self.supports?(_klass); true end
+module Fabrication
+  module Generator
+    class Base
+      def self.supports?(_klass)
+        true
+      end
 
-  def build(attributes=[], callbacks={})
-    process_attributes(attributes)
+      def build(attributes = [], callbacks = {})
+        process_attributes(attributes)
 
-    if callbacks[:initialize_with]
-      build_instance_with_constructor_override(callbacks[:initialize_with])
-    elsif callbacks[:on_init]
-      build_instance_with_init_callback(callbacks[:on_init])
-    else
-      build_instance
-    end
-    execute_callbacks(callbacks[:after_build])
-    _instance
-  end
+        if callbacks[:initialize_with]
+          build_instance_with_constructor_override(callbacks[:initialize_with])
+        elsif callbacks[:on_init]
+          build_instance_with_init_callback(callbacks[:on_init])
+        else
+          build_instance
+        end
+        execute_callbacks(callbacks[:after_build])
+        _instance
+      end
 
-  def create(attributes=[], callbacks=[])
-    build(attributes, callbacks)
-    execute_callbacks(callbacks[:before_validation])
-    execute_callbacks(callbacks[:after_validation])
-    execute_callbacks(callbacks[:before_save])
-    execute_callbacks(callbacks[:before_create])
-    persist
-    execute_callbacks(callbacks[:after_create])
-    execute_callbacks(callbacks[:after_save])
-    _instance
-  end
+      def create(attributes = [], callbacks = [])
+        build(attributes, callbacks)
+        execute_callbacks(callbacks[:before_validation])
+        execute_callbacks(callbacks[:after_validation])
+        execute_callbacks(callbacks[:before_save])
+        execute_callbacks(callbacks[:before_create])
+        persist
+        execute_callbacks(callbacks[:after_create])
+        execute_callbacks(callbacks[:after_save])
+        _instance
+      end
 
-  def execute_callbacks(callbacks)
-    callbacks.each { |callback| _instance.instance_exec(_instance, _transient_attributes, &callback) } if callbacks
-  end
+      def execute_callbacks(callbacks)
+        callbacks&.each { |callback| _instance.instance_exec(_instance, _transient_attributes, &callback) }
+      end
 
-  def to_params(attributes=[])
-    process_attributes(attributes)
-    _attributes.respond_to?(:with_indifferent_access) ? _attributes.with_indifferent_access : _attributes
-  end
+      def to_params(attributes = [])
+        process_attributes(attributes)
+        _attributes.respond_to?(:with_indifferent_access) ? _attributes.with_indifferent_access : _attributes
+      end
 
-  def to_hash(attributes=[], callbacks=[])
-    process_attributes(attributes)
-    Fabrication::Support.hash_class.new.tap do |hash|
-      _attributes.map do |name, value|
-        if value && value.respond_to?(:id)
-          hash["#{name}_id"] = value.id
-        else
-          hash[name] = value
+      def to_hash(attributes = [], _callbacks = [])
+        process_attributes(attributes)
+        Fabrication::Support.hash_class.new.tap do |hash|
+          _attributes.map do |name, value|
+            if value.respond_to?(:id)
+              hash["#{name}_id"] = value.id
+            else
+              hash[name] = value
+            end
+          end
         end
       end
-    end
-  end
 
-  def build_instance_with_constructor_override(callback)
-    self._instance = instance_eval(&callback)
-    set_attributes
-  end
+      def build_instance_with_constructor_override(callback)
+        self._instance = instance_eval(&callback)
+        set_attributes
+      end
 
-  def build_instance_with_init_callback(callback)
-    self._instance = _klass.new(*callback.call)
-    set_attributes
-  end
+      def build_instance_with_init_callback(callback)
+        self._instance = _klass.new(*callback.call)
+        set_attributes
+      end
 
-  def build_instance
-    self._instance = _klass.new
-    set_attributes
-  end
+      def build_instance
+        self._instance = _klass.new
+        set_attributes
+      end
 
-  def set_attributes
-    _attributes.each do |k,v|
-      _instance.send("#{k}=", v)
-    end
-  end
+      def set_attributes
+        _attributes.each do |k, v|
+          _instance.send("#{k}=", v)
+        end
+      end
 
-  def initialize(klass)
-    self._klass = klass
-  end
+      def initialize(klass)
+        self._klass = klass
+      end
 
-  def method_missing(method_name, *args, &block)
-    _attributes[method_name] || super
-  end
+      def respond_to_missing?(method_name, _include_private = false)
+        _attributes.key?(method_name)
+      end
 
-  protected
+      def method_missing(method_name, *args, &block)
+        _attributes.fetch(method_name) { super }
+      end
 
-  attr_accessor :_klass, :_instance, :_transient_attributes
+      protected
 
-  def _attributes
-    @_attributes ||= {}
-  end
+      attr_accessor :_klass, :_instance, :_transient_attributes
 
-  def persist
-    _instance.save! if _instance.respond_to?(:save!)
-  end
+      def _attributes
+        @_attributes ||= {}
+      end
 
-  def process_attributes(attributes)
-    self._transient_attributes = Hash.new
-    attributes.each do |attribute|
-      _attributes[attribute.name] = attribute.processed_value(_attributes)
-      _transient_attributes[attribute.name] = _attributes[attribute.name] if attribute.transient?
+      def persist
+        _instance.save! if _instance.respond_to?(:save!)
+      end
+
+      def process_attributes(attributes)
+        self._transient_attributes = ({})
+        attributes.each do |attribute|
+          _attributes[attribute.name] = attribute.processed_value(_attributes)
+          _transient_attributes[attribute.name] = _attributes[attribute.name] if attribute.transient?
+        end
+        _attributes.reject! { |k| _transient_attributes.keys.include?(k) }
+      end
     end
-    _attributes.reject! { |k| _transient_attributes.keys.include?(k) }
   end
-
 end