fabrication 3.0.0.beta.1.1 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3153c373659350c2969d98f3d21cbc60c92f9aff1f00c51f32c7238357c49195
-  data.tar.gz: d69204cacb17bfab516ecbe93d2e05edb60c596052130a1b41340e699dc25412
+  metadata.gz: e2d9e7e01f4fcab4cb03ccb401f16b62a5aa854e132627292a0dfaa6e57ede61
+  data.tar.gz: a5ef27ece35d6d35a06bcf341b001c06aa9bc1c5270d6305c7ad01344fc5cc21
 SHA512:
-  metadata.gz: 99e08637411f94b9df1ff63572c85b9b5fc8016677d043f53b1fb2acf27495b8f1cd1162b63cc6ed6be7579facf5e6dcc9c0929d2374fb6e7b30570308e33184
-  data.tar.gz: abffe3aeb00cb0b29589ad12daa9710801bdaecf5898d46b40e7cefa5150a0d00464df300c9edc54e22092097cdd0c712af0af5ae6b9f11f0ccd9965ce9b7582
+  metadata.gz: 916b51d8df3521c9423be89cb39e975a9d5e0f7a94d10b42b9c88599aa9b8a8e14163d149da0c231b87f950e247350f7177f157dcdce748bab3226d1db1a4a91
+  data.tar.gz: 167c0c2ab653376eb59e7217bf1e32c766284e9a776090738345e5f89695bc87c558129ad20ed9fc66b053b446c2d3dcdf3a3f296461f81860be43db23f7ada8

data/README.markdown

@@ -12,6 +12,6 @@ Fabrication is tested against all officially supported versions of Ruby.
 
 Please see the Fabrication website for up-to-date documentation: http://fabricationgem.org
 
-You can also view the raw documentation without all the awesome: https://github.com/paulelliott/fabrication-site/blob/master/source/index.markdown
+You can also view the raw documentation without all the awesome: https://gitlab.com/fabrication-gem/docsite/-/blob/master/source/index.html.markdown
 
-Get help from the mailing list: https://groups.google.com/group/fabricationgem
+Get help by opening an issue: https://gitlab.com/fabrication-gem/fabrication/-/issues

data/lib/fabricate.rb

@@ -1,40 +1,46 @@
 class Fabricate
-  def self.times(count, name, overrides = {}, &block)
-    count.times.map { Fabricate(name, overrides, &block) }
+  def self.times(count, name, overrides = {}, &)
+    Array.new(count).map { Fabricate(name, overrides, &) }
   end
 
-  def self.build_times(count, name, overrides = {}, &block)
-    count.times.map { Fabricate.build(name, overrides, &block) }
+  def self.build_times(count, name, overrides = {}, &)
+    Array.new(count).map { Fabricate.build(name, overrides, &) }
   end
 
-  def self.attributes_for_times(count, name, overrides = {}, &block)
-    count.times.map { Fabricate.attributes_for(name, overrides, &block) }
+  def self.attributes_for_times(count, name, overrides = {}, &)
+    Array.new(count).map { Fabricate.attributes_for(name, overrides, &) }
   end
 
-  def self.attributes_for(name, overrides = {}, &block)
+  def self.attributes_for(name, overrides = {}, &)
     fail_if_initializing(name)
-    schematic(name).to_attributes(overrides, &block)
+    schematic(name).to_attributes(overrides, &)
   end
 
-  def self.to_params(name, overrides = {}, &block)
+  def self.to_params(name, overrides = {}, &)
     fail_if_initializing(name)
-    schematic(name).to_params(overrides, &block)
+    schematic(name).to_params(overrides, &)
   end
 
-  def self.build(name, overrides = {}, &block)
+  def self.build(name, overrides = {}, &)
     fail_if_initializing(name)
-    schematic(name).build(overrides, &block).tap do |object|
-      Fabrication::Cucumber::Fabrications[name] = object if Fabrication::Config.register_with_steps?
+    schematic(name).build(overrides, &).tap do |object|
+      Fabrication::Config.notifiers.each do |notifier|
+        notifier.call(name, object)
+      end
     end
   end
 
-  def self.create(name, overrides = {}, &block)
+  def self.create(name, overrides = {}, &)
     fail_if_initializing(name)
-    schematic(name).fabricate(overrides, &block)
+    schematic(name).fabricate(overrides, &).tap do |object|
+      Fabrication::Config.notifiers.each do |notifier|
+        notifier.call(name, object)
+      end
+    end
   end
 
-  def self.sequence(name = Fabrication::Sequencer::DEFAULT, start = nil, &block)
-    Fabrication::Sequencer.sequence(name, start, &block)
+  def self.sequence(name = Fabrication::Sequencer::DEFAULT, start = nil, &)
+    Fabrication::Sequencer.sequence(name, start, &)
   end
 
   def self.schematic(name)

data/lib/fabrication/config.rb

@@ -1,3 +1,5 @@
+require 'logger'
+
 module Fabrication
   module Config
     extend self
@@ -14,16 +16,34 @@ module Fabrication
               nil
     end
 
+    attr_writer :logger, :sequence_start
+
+    def logger
+      @logger ||= Logger.new($stdout).tap do |logger|
+        logger.level = Logger::WARN
+      end
+    end
+
     def fabricator_path
       @fabricator_path ||= ['test/fabricators', 'spec/fabricators']
     end
     alias fabricator_paths fabricator_path
 
+    def fabricator_dir
+      Support.log_deprecation('Fabrication::Config.fabricator_dir has been ' \
+                              'replaced by Fabrication::Config.fabricator_path')
+      fabricator_path
+    end
+
     def fabricator_path=(folders)
       @fabricator_path = ([] << folders).flatten
     end
 
-    attr_writer :sequence_start, :register_with_steps
+    def fabricator_dir=(folders)
+      Support.log_deprecation('Fabrication::Config.fabricator_dir has been ' \
+                              'replaced by Fabrication::Config.fabricator_path')
+      self.fabricator_path = folders
+    end
 
     def sequence_start
       @sequence_start ||= 0
@@ -38,10 +58,6 @@ module Fabrication
     end
     alias path_prefixes path_prefix
 
-    def register_with_steps?
-      @register_with_steps ||= nil
-    end
-
     def generators
       @generators ||= []
     end
@@ -57,5 +73,26 @@ module Fabrication
     def recursion_limit=(limit)
       @recursion_limit = limit
     end
+
+    def register_with_steps=(value)
+      Support.log_deprecation(
+        'Fabrication::Config.register_with_steps has been deprecated. ' \
+        'Please regenerate your cucumber steps with `rails g fabrication:cucumber_steps'
+      )
+
+      return unless value
+
+      register_notifier do |name, object|
+        Fabrication::Cucumber::Fabrications[name] = object
+      end
+    end
+
+    def notifiers
+      @notifiers ||= []
+    end
+
+    def register_notifier(&block)
+      notifiers.push(block)
+    end
   end
 end

data/lib/fabrication/cucumber/step_fabricator.rb

@@ -1,3 +1,5 @@
+require 'singleton'
+
 module Fabrication
   module Cucumber
     class StepFabricator
@@ -20,7 +22,7 @@ module Fabrication
       end
 
       def n(count, attrs = {})
-        count.times.map { make(attrs) }.tap { |o| remember(o) }
+        Array.new(count).map { make(attrs) }.tap { |o| remember(o) }
       end
 
       # rubocop:disable Naming/PredicateName
@@ -28,7 +30,7 @@ module Fabrication
         instance = Fabrications[@fabricator]
         children = dehumanize(children)
         [Fabrications[children]].flatten.each do |child|
-          child.send("#{klass.to_s.underscore.downcase}=", instance)
+          child.send(:"#{klass.to_s.underscore.downcase}=", instance)
           child.respond_to?(:save!) && child.save!
         end
       end
@@ -76,7 +78,7 @@ module Fabrication
         parent_class_name = parent.class.to_s.underscore
 
         parent_instance = parent
-        unless klass.new.respond_to?("#{parent_class_name}=")
+        unless klass.new.respond_to?(:"#{parent_class_name}=")
           parent_class_name = parent_class_name.pluralize
           parent_instance = [parent]
         end
@@ -85,17 +87,23 @@ module Fabrication
       end
     end
 
-    module Fabrications
+    class Fabrications
+      include Singleton
+
       def self.fabrications
-        @fabrications ||= {}
+        instance.fabrications
       end
 
       def self.[](fabricator)
-        fabrications[fabricator.to_sym]
+        instance.fabrications[fabricator.to_sym]
       end
 
       def self.[]=(fabricator, fabrication)
-        fabrications[fabricator.to_sym] = fabrication
+        instance.fabrications[fabricator.to_sym] = fabrication
+      end
+
+      def fabrications
+        @fabrications ||= {}
       end
     end
   end

data/lib/fabrication/generator/active_record.rb

@@ -6,15 +6,15 @@ module Fabrication
         # 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
+        (defined?(::ActiveRecord::Base) &&
+          klass.ancestors.include?(::ActiveRecord::Base)) || false
       end
 
       def build_instance
-        self._instance = if _klass.respond_to?(:protected_attributes)
-                           _klass.new(_attributes, without_protection: true)
+        self._instance = if resolved_class.respond_to?(:protected_attributes)
+                           resolved_class.new(_attributes, without_protection: true)
                          else
-                           _klass.new(_attributes)
+                           resolved_class.new(_attributes)
                          end
       end
     end

data/lib/fabrication/generator/base.rb

@@ -1,7 +1,7 @@
 module Fabrication
   module Generator
     class Base
-      def self.supports?(_klass)
+      def self.supports?(_resolved_class)
         true
       end
 
@@ -11,6 +11,9 @@ module Fabrication
         if callbacks[:initialize_with]
           build_instance_with_constructor_override(callbacks[:initialize_with])
         elsif callbacks[:on_init]
+          Fabrication::Support.log_deprecation(
+            'The on_init callback has been replaced by initialize_with. Please see the documentation for usage'
+          )
           build_instance_with_init_callback(callbacks[:on_init])
         else
           build_instance
@@ -19,18 +22,29 @@ module Fabrication
         _instance
       end
 
-      def create(attributes = [], callbacks = [])
+      def create(attributes = [], callbacks = {})
         build(attributes, callbacks)
-        execute_callbacks(callbacks[:before_validation])
-        execute_callbacks(callbacks[:after_validation])
-        execute_callbacks(callbacks[:before_save])
+        execute_deprecated_callbacks(callbacks, :before_validation, :before_create)
+        execute_deprecated_callbacks(callbacks, :after_validation, :before_create)
+        execute_deprecated_callbacks(callbacks, :before_save, :before_create)
         execute_callbacks(callbacks[:before_create])
         persist
         execute_callbacks(callbacks[:after_create])
-        execute_callbacks(callbacks[:after_save])
+        execute_deprecated_callbacks(callbacks, :after_save, :after_create)
         _instance
       end
 
+      def execute_deprecated_callbacks(callbacks, callback_type, replacement_callback)
+        if callbacks[callback_type]
+          Fabrication::Support.log_deprecation(
+            "Using #{callback_type} is deprecated but you can replace it " \
+            "with #{replacement_callback} with the same result."
+          )
+        end
+
+        execute_callbacks(callbacks[callback_type])
+      end
+
       def execute_callbacks(callbacks)
         callbacks&.each { |callback| _instance.instance_exec(_instance, _transient_attributes, &callback) }
       end
@@ -54,61 +68,68 @@ module Fabrication
       end
 
       def build_instance_with_constructor_override(callback)
-        self._instance = instance_eval(&callback)
+        self._instance = instance_exec(_transient_attributes, &callback)
         set_attributes
       end
 
       def build_instance_with_init_callback(callback)
-        self._instance = _klass.new(*callback.call)
+        self._instance = resolved_class.new(*callback.call(_transient_attributes))
         set_attributes
       end
 
       def build_instance
-        self._instance = _klass.new
+        self._instance = resolved_class.new
         set_attributes
       end
 
       def set_attributes
-        if _instance.respond_to?(:attributes=)
-          _instance.attributes = _attributes
-        else
-          _attributes.each do |k, v|
-            _instance.send("#{k}=", v)
-          end
+        _attributes.each do |k, v|
+          _instance.send(:"#{k}=", v)
         end
       end
 
-      def initialize(klass)
-        self._klass = klass
+      def initialize(resolved_class)
+        self.resolved_class = resolved_class
       end
 
       def respond_to_missing?(method_name, _include_private = false)
         _attributes.key?(method_name)
       end
 
-      def method_missing(method_name, *args, &block)
+      def method_missing(method_name, *args, &)
         _attributes.fetch(method_name) { super }
       end
 
+      def _klass
+        Fabrication::Support.log_deprecation(
+          'The `_klass` method in fabricator definitions has been replaced by `resolved_class`'
+        )
+
+        resolved_class
+      end
+
       protected
 
-      attr_accessor :_klass, :_instance, :_transient_attributes
+      attr_accessor :resolved_class, :_instance
 
       def _attributes
         @_attributes ||= {}
       end
 
+      def _transient_attributes
+        @_transient_attributes ||= {}
+      end
+
       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) }
+        _attributes.reject! { |k| _transient_attributes.key?(k) }
       end
     end
   end

data/lib/fabrication/generator/mongoid.rb

@@ -0,0 +1,17 @@
+module Fabrication
+  module Generator
+    class Mongoid < Fabrication::Generator::Base
+      def self.supports?(klass)
+        defined?(::Mongoid) && klass.ancestors.include?(::Mongoid::Document)
+      end
+
+      def build_instance
+        self._instance = if resolved_class.respond_to?(:protected_attributes)
+                           resolved_class.new(_attributes, without_protection: true)
+                         else
+                           resolved_class.new(_attributes)
+                         end
+      end
+    end
+  end
+end

data/lib/fabrication/generator/sequel.rb

@@ -7,18 +7,15 @@ module Fabrication
       end
 
       def self.supports?(klass)
-        defined?(::Sequel) && defined?(::Sequel::Model) && klass.ancestors.include?(::Sequel::Model)
+        defined?(::Sequel::Model) && klass.ancestors.include?(::Sequel::Model)
       end
 
       def set_attributes
-        _attributes.each do |key, value|
-          if (reflection = _klass.association_reflections[key]) && value.is_a?(Array)
-            _instance.associations[key] = value
-            _instance.after_save_hook do
-              value.each { |o| _instance.send(reflection.add_method, o) }
-            end
+        _attributes.each do |field_name, value|
+          if value.is_a?(Array) && (association = association_for(field_name))
+            set_association(association, field_name, value)
           else
-            _instance.send("#{key}=", value)
+            set_attribute(field_name, value)
           end
         end
       end
@@ -29,8 +26,23 @@ module Fabrication
 
       private
 
+      def association_for(field_name)
+        resolved_class.association_reflections[field_name]
+      end
+
+      def set_attribute(field_name, value)
+        _instance.send(:"#{field_name}=", value)
+      end
+
+      def set_association(association, field_name, value)
+        _instance.associations[field_name] = value
+        _instance.after_save_hook do
+          value.each { |o| _instance.send(association.add_method, o) }
+        end
+      end
+
       def load_instance_hooks
-        klass = _klass.respond_to?(:cti_base_model) ? _klass.cti_models.first : _klass
+        klass = resolved_class.respond_to?(:cti_base_model) ? resolved_class.cti_models.first : resolved_class
         klass.plugin :instance_hooks unless klass.new.respond_to? :after_save_hook
       end
     end

data/lib/fabrication/schematic/attribute.rb

@@ -43,8 +43,8 @@ module Fabrication
 
       private
 
-      def execute(*args, &block)
-        Fabrication::Schematic::Runner.new(klass).instance_exec(*args, &block)
+      def execute(...)
+        Fabrication::Schematic::Runner.new(klass).instance_exec(...)
       end
 
       def process_count
@@ -65,7 +65,7 @@ module Fabrication
       end
 
       def rand_range
-        Kernel.rand((params[:start_range]..params[:end_range])) if params[:start_range] && params[:end_range]
+        Kernel.rand(params[:start_range]..params[:end_range]) if params[:start_range] && params[:end_range]
       end
     end
   end

data/lib/fabrication/schematic/definition.rb

@@ -4,6 +4,7 @@ module Fabrication
       GENERATORS = [
         Fabrication::Generator::ActiveRecord,
         Fabrication::Generator::Sequel,
+        Fabrication::Generator::Mongoid,
         Fabrication::Generator::Base
       ].freeze
 
@@ -16,15 +17,15 @@ module Fabrication
       end
 
       def process_block(&block)
-        Fabrication::Schematic::Evaluator.new.process(self, &block) if block_given?
+        Fabrication::Schematic::Evaluator.new.process(self, &block) if block
       end
 
       def attribute(name)
         attributes.detect { |a| a.name == name }
       end
 
-      def append_or_update_attribute(attribute_name, value, params = {}, &block)
-        attribute = Fabrication::Schematic::Attribute.new(klass, attribute_name, value, params, &block)
+      def append_or_update_attribute(attribute_name, value, params = {}, &)
+        attribute = Fabrication::Schematic::Attribute.new(klass, attribute_name, value, params, &)
         index = attributes.index { |a| a.name == attribute.name }
 
         if index
@@ -55,14 +56,14 @@ module Fabrication
         attributes.select(&:value_static?) + attributes.select(&:value_proc?)
       end
 
-      def build(overrides = {}, &block)
+      def build(overrides = {}, &)
         Fabrication.manager.prevent_recursion!
         if Fabrication.manager.to_params_stack.any?
-          to_params(overrides, &block)
+          to_params(overrides, &)
         else
           begin
             Fabrication.manager.build_stack << name
-            merge(overrides, &block).instance_eval do
+            merge(overrides, &).instance_eval do
               generator.new(klass).build(sorted_attributes, callbacks)
             end
           ensure
@@ -71,16 +72,16 @@ module Fabrication
         end
       end
 
-      def fabricate(overrides = {}, &block)
+      def fabricate(overrides = {}, &)
         Fabrication.manager.prevent_recursion!
         if Fabrication.manager.build_stack.any?
-          build(overrides, &block)
+          build(overrides, &)
         elsif Fabrication.manager.to_params_stack.any?
-          to_params(overrides, &block)
+          to_params(overrides, &)
         else
           begin
             Fabrication.manager.create_stack << name
-            merge(overrides, &block).instance_eval do
+            merge(overrides, &).instance_eval do
               generator.new(klass).create(sorted_attributes, callbacks)
             end
           ensure
@@ -89,18 +90,18 @@ module Fabrication
         end
       end
 
-      def to_params(overrides = {}, &block)
+      def to_params(overrides = {}, &)
         Fabrication.manager.prevent_recursion!
         Fabrication.manager.to_params_stack << name
-        merge(overrides, &block).instance_eval do
+        merge(overrides, &).instance_eval do
           generator.new(klass).to_params(sorted_attributes)
         end
       ensure
         Fabrication.manager.to_params_stack.pop
       end
 
-      def to_attributes(overrides = {}, &block)
-        merge(overrides, &block).instance_eval do
+      def to_attributes(overrides = {}, &)
+        merge(overrides, &).instance_eval do
           generator.new(klass).to_hash(sorted_attributes, callbacks)
         end
       end
@@ -123,9 +124,9 @@ module Fabrication
         end
       end
 
-      def merge(overrides = {}, &block)
+      def merge(overrides = {}, &)
         clone.tap do |definition|
-          definition.process_block(&block)
+          definition.process_block(&)
           overrides.each do |name, value|
             definition.append_or_update_attribute(name.to_sym, value)
           end

data/lib/fabrication/schematic/evaluator.rb

@@ -1,9 +1,9 @@
 module Fabrication
   module Schematic
     class Evaluator < BasicObject
-      def process(definition, &block)
+      def process(definition, &)
         @_definition = definition
-        instance_eval(&block)
+        instance_eval(&)
       end
 
       def respond_to_missing?(_method_name, _include_private = false)

data/lib/fabrication/schematic/manager.rb

@@ -30,10 +30,10 @@ module Fabrication
         @initializing = false
       end
 
-      def register(name, options, &block)
+      def register(name, options, &)
         name = name.to_sym
         raise_if_registered(name)
-        store(name, Array(options.delete(:aliases)), options, &block)
+        store(name, Array(options.delete(:aliases)), options, &)
       end
 
       def [](name)
@@ -55,14 +55,16 @@ module Fabrication
       def load_definitions
         preinitialize
         Fabrication::Config.path_prefixes.each do |prefix|
-          Fabrication::Config.fabricator_paths.each do |folder|
-            Dir.glob(File.join(prefix.to_s, folder, '**', '*.rb')).sort.each do |file|
-              load file
+          Fabrication::Config.fabricator_paths.each do |path|
+            if File.file?(path)
+              load path
+            else
+              Dir.glob(File.join(prefix.to_s, path, '**', '*.rb')).each do |file|
+                load file
+              end
             end
           end
         end
-      rescue StandardError => e
-        raise e
       ensure
         freeze
       end
@@ -79,8 +81,8 @@ module Fabrication
         (raise Fabrication::DuplicateFabricatorError, name) if self[name]
       end
 
-      def store(name, aliases, options, &block)
-        schematic = schematics[name] = Fabrication::Schematic::Definition.new(name, options, &block)
+      def store(name, aliases, options, &)
+        schematic = schematics[name] = Fabrication::Schematic::Definition.new(name, options, &)
         aliases.each { |as| schematics[as.to_sym] = schematic }
       end
     end

data/lib/fabrication/schematic/runner.rb

@@ -7,9 +7,9 @@ module Fabrication
         self.klass = klass
       end
 
-      def sequence(name = Fabrication::Sequencer::DEFAULT, start = nil, &block)
-        name = "#{klass.to_s.downcase.gsub(/::/, '_')}_#{name}"
-        Fabrication::Sequencer.sequence(name, start, &block)
+      def sequence(name = Fabrication::Sequencer::DEFAULT, start = nil, &)
+        name = "#{klass.to_s.downcase.gsub('::', '_')}_#{name}"
+        Fabrication::Sequencer.sequence(name, start, &)
       end
     end
   end

data/lib/fabrication/sequencer.rb

@@ -1,27 +1,40 @@
+require 'singleton'
+
 module Fabrication
   class Sequencer
+    include Singleton
+
     DEFAULT = :_default
 
-    def self.sequence(name = DEFAULT, start = nil, &block)
+    def self.sequence(name = DEFAULT, start = nil, &)
+      instance.sequence(name, start, &)
+    end
+
+    def self.clear
+      instance.sequences.clear
+      instance.sequence_blocks.clear
+    end
+
+    def sequence(name = DEFAULT, start = nil, &block)
       idx = sequences[name] ||= start || Fabrication::Config.sequence_start
-      if block_given?
+      if block
         sequence_blocks[name] = block.to_proc
       else
         sequence_blocks[name] ||= ->(i) { i }
       end.call(idx).tap do
-        sequences[name] += 1
+        sequences[name] = idx.succ
       end
     end
 
-    def self.sequences
+    def sequences
       @sequences ||= {}
     end
 
-    def self.sequence_blocks
+    def sequence_blocks
       @sequence_blocks ||= {}
     end
 
-    def self.reset
+    def reset
       Fabrication::Config.sequence_start = nil
       @sequences = nil
       @sequence_blocks = nil

data/lib/fabrication/support.rb

@@ -1,73 +1,68 @@
 module Fabrication
-  class Support
-    class << self
-      def fabricatable?(name)
-        Fabrication.manager[name] || class_for(name)
-      end
+  module Support
+    extend self
 
-      def class_for(class_or_to_s)
-        class_name = variable_name_to_class_name(class_or_to_s)
-        constantize(class_name)
-      rescue NameError => e
-        raise Fabrication::UnfabricatableError.new(class_or_to_s, e)
-      end
+    def fabricatable?(name)
+      Fabrication.manager[name] || class_for(name)
+    end
 
-      def constantize(camel_cased_word)
-        names = camel_cased_word.split('::')
-        Object.const_get(camel_cased_word) if names.empty?
-        names.shift if names.size > 1 && names.first.empty?
-        names.inject(Object) do |constant, name|
-          if constant == Object
-            constant.const_get(name)
-          else
-            candidate = constant.const_get(name)
-            next candidate if constant.const_defined?(name, false)
-            next candidate unless Object.const_defined?(name)
+    def log_deprecation(message)
+      Config.logger.warn("[DEPRECATION][fabrication] #{message}")
+    end
 
-            constant = constant.ancestors.inject do |const, ancestor|
-              break const    if ancestor == Object
-              break ancestor if ancestor.const_defined?(name, false)
+    def class_for(class_or_to_s)
+      constantize(variable_name_to_class_name(class_or_to_s))
+    rescue NameError => e
+      raise Fabrication::UnfabricatableError.new(class_or_to_s, e)
+    end
 
-              const
-            end
-            constant.const_get(name, false)
-          end
-        end
-      end
+    def constantize(camel_cased_word)
+      return camel_cased_word if camel_cased_word.is_a?(Class)
 
-      def extract_options!(args)
-        args.last.is_a?(::Hash) ? args.pop : {}
+      camel_cased_word.to_s.split('::').reduce(Object) do |resolved_class, class_part|
+        resolved_class.const_get(class_part)
       end
+    end
 
-      def variable_name_to_class_name(name)
-        name_string = name.to_s
+    def extract_options!(args)
+      args.last.is_a?(::Hash) ? args.pop : {}
+    end
 
-        if name_string.respond_to?(:camelize)
-          name_string.camelize
-        else
-          name_string.gsub(%r{/(.?)}) do
-            "::#{Regexp.last_match(1).upcase}"
-          end.gsub(/(?:^|_)(.)/) { Regexp.last_match(1).upcase }
-        end
-      end
+    def variable_name_to_class_name(name)
+      name_string = name.to_s
 
-      def hash_class
-        @hash_class ||= defined?(HashWithIndifferentAccess) ? HashWithIndifferentAccess : Hash
+      if name_string.respond_to?(:camelize)
+        name_string.camelize
+      else
+        name_string
+          .gsub(%r{/(.?)}) { "::#{Regexp.last_match(1).upcase}" }
+          .gsub(/(?:^|_)(.)/) { Regexp.last_match(1).upcase }
       end
+    end
 
-      def singularize(string)
-        string.singularize
-      rescue StandardError
-        string.end_with?('s') ? string[0..-2] : string
-      end
+    def find_definitions
+      log_deprecation('Fabrication::Support.find_definitions has been replaced by ' \
+                      'Fabrication.manager.load_definitions and will be removed in 3.0.0.')
 
-      def underscore(string)
-        string.gsub(/::/, '/')
-              .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
-              .gsub(/([a-z\d])([A-Z])/, '\1_\2')
-              .tr('-', '_')
-              .downcase
-      end
+      Fabrication.manager.load_definitions
+    end
+
+    def hash_class
+      @hash_class ||= defined?(HashWithIndifferentAccess) ? HashWithIndifferentAccess : Hash
+    end
+
+    def singularize(string)
+      string.singularize
+    rescue StandardError
+      string.end_with?('s') ? string[0..-2] : string
+    end
+
+    def underscore(string)
+      string.gsub('::', '/')
+            .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+            .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+            .tr('-', '_')
+            .downcase
     end
   end
 end

data/lib/fabrication/syntax/make.rb

@@ -11,18 +11,18 @@ module Fabrication
     #
     #
     module Make
-      def make(*args, &block)
+      def make(*args, &)
         overrides = Fabrication::Support.extract_options!(args)
         klass = Fabrication::Support.underscore(name).to_sym
         fabricator_name = args.first.is_a?(Symbol) ? "#{klass}_#{args.first}" : klass
-        Fabricate.build(fabricator_name, overrides, &block)
+        Fabricate.build(fabricator_name, overrides, &)
       end
 
-      def make!(*args, &block)
+      def make!(*args, &)
         overrides = Fabrication::Support.extract_options!(args)
         klass = Fabrication::Support.underscore(name).to_sym
         fabricator_name = args.first.is_a?(Symbol) ? "#{klass}_#{args.first}" : klass
-        Fabricate(fabricator_name, overrides, &block)
+        Fabricate(fabricator_name, overrides, &)
       end
     end
   end

data/lib/fabrication/transform.rb

@@ -1,37 +1,39 @@
+require 'singleton'
+
 module Fabrication
   class Transform
+    include Singleton
+
     class << self
       def apply_to(schematic, attributes_hash)
         Fabrication.manager.load_definitions if Fabrication.manager.empty?
-        attributes_hash.inject({}) { |h, (k, v)| h.update(k => apply_transform(schematic, k, v)) }
+        attributes_hash.inject({}) { |h, (k, v)| h.update(k => instance.apply_transform(schematic, k, v)) }
       end
 
       def clear_all
-        @transforms = nil
-        @overrides = nil
+        instance.transforms.clear
+        instance.overrides.clear
       end
 
       def define(attribute, transform)
-        transforms[attribute] = transform
+        instance.transforms[attribute] = transform
       end
 
       def only_for(schematic, attribute, transform)
-        overrides[schematic] = (overrides[schematic] || {}).merge!(attribute => transform)
+        instance.overrides[schematic] = (instance.overrides[schematic] || {}).merge!(attribute => transform)
       end
+    end
 
-      private
-
-      def overrides
-        @overrides ||= {}
-      end
+    def overrides
+      @overrides ||= {}
+    end
 
-      def apply_transform(schematic, attribute, value)
-        overrides.fetch(schematic, transforms)[attribute].call(value)
-      end
+    def apply_transform(schematic, attribute, value)
+      overrides.fetch(schematic, transforms)[attribute].call(value)
+    end
 
-      def transforms
-        @transforms ||= Hash.new(->(value) { value })
-      end
+    def transforms
+      @transforms ||= Hash.new(->(value) { value })
     end
   end
 end

data/lib/fabrication/version.rb

@@ -1,3 +1,3 @@
 module Fabrication
-  VERSION = '3.0.0.beta.1.1'.freeze
+  VERSION = '3.0.0'.freeze
 end

data/lib/fabrication.rb

@@ -31,34 +31,38 @@ module Fabrication
 
   module Generator
     autoload :ActiveRecord,  'fabrication/generator/active_record'
-    autoload :ActiveRecord4, 'fabrication/generator/active_record_4'
+    autoload :Mongoid,       'fabrication/generator/mongoid'
     autoload :Sequel,        'fabrication/generator/sequel'
     autoload :Base,          'fabrication/generator/base'
   end
 
   def self.clear_definitions
     manager.clear
-    Sequencer.sequences.clear
+    Sequencer.clear
   end
 
-  def self.configure(&block)
-    Fabrication::Config.configure(&block)
+  def self.configure(&)
+    Fabrication::Config.configure(&)
   end
 
   def self.manager
-    @manager ||= Fabrication::Schematic::Manager.instance
+    Fabrication::Schematic::Manager.instance
+  end
+
+  def self.schematics
+    Support.log_deprecation('Fabrication.schematics has been replaced by ' \
+                            'Fabrication.manager and will be removed in 3.0.0.')
+    manager
   end
 end
 
 # rubocop:disable Naming/MethodName
-def Fabricator(name, options = {}, &block)
-  Fabrication.manager.register(name, options, &block)
+def Fabricator(name, options = {}, &)
+  Fabrication.manager.register(name, options, &)
 end
 
-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
+def Fabricate(name, overrides = {}, &)
+  Fabricate.create(name, overrides, &)
 end
 # rubocop:enable Naming/MethodName
 

data/lib/rails/generators/fabrication/cucumber_steps/cucumber_steps_generator.rb

@@ -8,7 +8,7 @@ module Fabrication
       end
 
       def self.source_root
-        @source_root ||= File.expand_path(File.join(File.dirname(__FILE__), 'templates'))
+        File.expand_path(File.join(File.dirname(__FILE__), 'templates'))
       end
     end
   end

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

@@ -1,12 +1,14 @@
 World(FabricationMethods)
 
-Fabrication::Config.register_with_steps = true
+Fabrication::Config.register_notifier do |name, object|
+  Fabrication::Cucumber::Fabrications[name] = object
+end
 
 def with_ivars(fabricator)
   @they = yield fabricator
   model = @they.last.class.to_s.underscore
-  instance_variable_set("@#{model.pluralize}", @they)
-  instance_variable_set("@#{model.singularize}", @they.last)
+  instance_variable_set(:"@#{model.pluralize}", @they)
+  instance_variable_set(:"@#{model.singularize}", @they.last)
   Fabrication::Cucumber::Fabrications[model.singularize.gsub(/\W+/, '_').downcase] = @they.last
 end
 
@@ -23,13 +25,13 @@ Given(/^the following ([^"]*):$/) do |model_name, table|
 end
 
 Given(/^that ([^"]*) has the following ([^"]*):$/) do |parent, child, table|
-  with_ivars Fabrication::Cucumber::StepFabricator.new(child, parent: parent) do |fab|
+  with_ivars Fabrication::Cucumber::StepFabricator.new(child, parent:) do |fab|
     fab.from_table(table)
   end
 end
 
 Given(/^that ([^"]*) has (\d+) ([^"]*)$/) do |parent, count, child|
-  with_ivars Fabrication::Cucumber::StepFabricator.new(child, parent: parent) do |fab|
+  with_ivars Fabrication::Cucumber::StepFabricator.new(child, parent:) do |fab|
     fab.n(count.to_i)
   end
 end

data/lib/rails/generators/fabrication/model/model_generator.rb

@@ -19,7 +19,7 @@ module Fabrication
       end
 
       def self.source_root
-        @source_root ||= File.expand_path(File.join(File.dirname(__FILE__), 'templates'))
+        File.expand_path(File.join(File.dirname(__FILE__), 'templates'))
       end
 
       private
@@ -33,6 +33,8 @@ module Fabrication
         end
       rescue StandardError
         # no table? no problem!
+      rescue LoadError
+        # cannot find model file. This means it was already destroyed, so just continue.
       end
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fabrication
 version: !ruby/object:Gem::Version
-  version: 3.0.0.beta.1.1
+  version: 3.0.0
 platform: ruby
 authors:
 - Paul Elliott
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-07-16 00:00:00.000000000 Z
+date: 2025-05-29 00:00:00.000000000 Z
 dependencies: []
 description: Fabrication is an object generation framework for ActiveRecord, Mongoid,
   Sequel, or any other Ruby object.
@@ -32,6 +32,7 @@ files:
 - lib/fabrication/errors/unknown_fabricator_error.rb
 - lib/fabrication/generator/active_record.rb
 - lib/fabrication/generator/base.rb
+- lib/fabrication/generator/mongoid.rb
 - lib/fabrication/generator/sequel.rb
 - lib/fabrication/railtie.rb
 - lib/fabrication/schematic/attribute.rb
@@ -52,8 +53,15 @@ files:
 homepage: http://fabricationgem.org
 licenses:
 - MIT
-metadata: {}
-post_install_message:
+metadata:
+  bug_tracker_uri: https://gitlab.com/fabrication-gem/fabrication/-/issues
+  changelog_uri: https://gitlab.com/fabrication-gem/fabrication/-/blob/master/Changelog.markdown
+  documentation_uri: https://fabricationgem.org
+  homepage_uri: https://fabricationgem.org
+  mailing_list_uri: https://groups.google.com/g/fabricationgem
+  rubygems_mfa_required: 'true'
+  source_code_uri: https://gitlab.com/fabrication-gem/fabrication
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -61,15 +69,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.5.0
+      version: 3.2.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
-rubygems_version: 3.1.6
-signing_key:
+rubygems_version: 3.4.19
+signing_key: 
 specification_version: 4
-summary: Implementing the factory pattern in Ruby so you don't have to.
+summary: Generates object instances for test suites, seed files, etc.
 test_files: []