fabrication 2.20.0 → 2.22.0

data/lib/fabrication/schematic/evaluator.rb

@@ -1,70 +1,77 @@
-class Fabrication::Schematic::Evaluator < BasicObject
+module Fabrication
+  module Schematic
+    class Evaluator < BasicObject
+      def process(definition, &block)
+        @_definition = definition
+        instance_eval(&block)
+      end
 
-  def process(definition, &block)
-    @_definition = definition
-    instance_eval(&block)
-  end
+      def respond_to_missing?(_method_name, _include_private = false)
+        true
+      end
 
-  def method_missing(method_name, *args, &block)
-    params = ::Fabrication::Support.extract_options!(args)
-    value = args.first
-    block = @_definition.generate_value(method_name, params) if args.empty? && !block
-    @_definition.append_or_update_attribute(method_name, value, params, &block)
-  end
+      def method_missing(method_name, *args, &block)
+        params = ::Fabrication::Support.extract_options!(args)
+        value = args.first
+        block = @_definition.generate_value(method_name, params) if args.empty? && !block
+        @_definition.append_or_update_attribute(method_name, value, params, &block)
+      end
 
-  def after_build(&block)
-    @_definition.callbacks[:after_build] ||= []
-    @_definition.callbacks[:after_build] << block
-  end
+      def after_build(&block)
+        @_definition.callbacks[:after_build] ||= []
+        @_definition.callbacks[:after_build] << block
+      end
 
-  def before_validation(&block)
-    @_definition.callbacks[:before_validation] ||= []
-    @_definition.callbacks[:before_validation] << block
-  end
+      def before_validation(&block)
+        @_definition.callbacks[:before_validation] ||= []
+        @_definition.callbacks[:before_validation] << block
+      end
 
-  def after_validation(&block)
-    @_definition.callbacks[:after_validation] ||= []
-    @_definition.callbacks[:after_validation] << block
-  end
+      def after_validation(&block)
+        @_definition.callbacks[:after_validation] ||= []
+        @_definition.callbacks[:after_validation] << block
+      end
 
-  def before_save(&block)
-    @_definition.callbacks[:before_save] ||= []
-    @_definition.callbacks[:before_save] << block
-  end
+      def before_save(&block)
+        @_definition.callbacks[:before_save] ||= []
+        @_definition.callbacks[:before_save] << block
+      end
 
-  def before_create(&block)
-    @_definition.callbacks[:before_create] ||= []
-    @_definition.callbacks[:before_create] << block
-  end
+      def before_create(&block)
+        @_definition.callbacks[:before_create] ||= []
+        @_definition.callbacks[:before_create] << block
+      end
 
-  def after_create(&block)
-    @_definition.callbacks[:after_create] ||= []
-    @_definition.callbacks[:after_create] << block
-  end
+      def after_create(&block)
+        @_definition.callbacks[:after_create] ||= []
+        @_definition.callbacks[:after_create] << block
+      end
 
-  def after_save(&block)
-    @_definition.callbacks[:after_save] ||= []
-    @_definition.callbacks[:after_save] << block
-  end
+      def after_save(&block)
+        @_definition.callbacks[:after_save] ||= []
+        @_definition.callbacks[:after_save] << block
+      end
 
-  def on_init(&block)
-    @_definition.callbacks[:on_init] = block
-  end
+      def on_init(&block)
+        @_definition.callbacks[:on_init] = block
+      end
 
-  def initialize_with(&block)
-    @_definition.callbacks[:initialize_with] = block
-  end
+      def initialize_with(&block)
+        @_definition.callbacks[:initialize_with] = block
+      end
 
-  def init_with(*args)
-    args
-  end
+      def init_with(*args)
+        args
+      end
 
-  def transient(*field_names)
-    field_names.each do |field_name|
-      if field_name.kind_of?(::Hash)
-        field_name.each_pair { |name, value| @_definition.append_or_update_attribute(name, value, transient: true) }
-      else
-        @_definition.append_or_update_attribute(field_name, nil, transient: true)
+      def transient(*field_names)
+        field_names.each do |field_name|
+          if field_name.is_a?(::Hash)
+            field_name.each_pair { |name, value| @_definition.append_or_update_attribute(name, value, transient: true) }
+          else
+            @_definition.append_or_update_attribute(field_name, nil, transient: true)
+          end
+        end
       end
     end
   end

data/lib/fabrication/schematic/manager.rb

@@ -1,80 +1,88 @@
 require 'singleton'
 
-class Fabrication::Schematic::Manager
-  include Singleton
+module Fabrication
+  module Schematic
+    class Manager
+      include Singleton
+
+      def preinitialize
+        @initializing = true
+        clear
+      end
 
-  def preinitialize
-    @initializing = true
-    clear
-  end
+      def initializing?
+        @initializing ||= nil
+      end
 
-  def initializing?
-    @initializing ||= nil
-  end
+      def schematics
+        @schematics ||= {}
+      end
 
-  def schematics
-    @schematics ||= {}
-  end
+      def clear
+        schematics.clear
+      end
 
-  def clear; schematics.clear end
-  def empty?; schematics.empty? end
+      def empty?
+        schematics.empty?
+      end
 
-  def freeze
-    @initializing = false
-  end
+      def freeze
+        @initializing = false
+      end
 
-  def register(name, options, &block)
-    name = name.to_sym
-    raise_if_registered(name)
-    store(name, Array(options.delete(:aliases)), options, &block)
-  end
+      def register(name, options, &block)
+        name = name.to_sym
+        raise_if_registered(name)
+        store(name, Array(options.delete(:aliases)), options, &block)
+      end
 
-  def [](name)
-    schematics[name.to_sym]
-  end
+      def [](name)
+        schematics[name.to_sym]
+      end
 
-  def create_stack
-    @create_stack ||= []
-  end
+      def create_stack
+        @create_stack ||= []
+      end
 
-  def build_stack
-    @build_stack ||= []
-  end
+      def build_stack
+        @build_stack ||= []
+      end
 
-  def to_params_stack
-    @to_params_stack ||= []
-  end
+      def to_params_stack
+        @to_params_stack ||= []
+      end
 
-  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
+      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
+            end
+          end
         end
+      rescue StandardError => e
+        raise e
+      ensure
+        freeze
       end
-    end
-  rescue Exception => e
-    raise e
-  ensure
-    freeze
-  end
 
-  def prevent_recursion!
-    (create_stack + build_stack + to_params_stack).group_by(&:to_sym).each do |name, values|
-      raise Fabrication::InfiniteRecursionError.new(name) if values.length > Fabrication::Config.recursion_limit
-    end
-  end
+      def prevent_recursion!
+        (create_stack + build_stack + to_params_stack).group_by(&:to_sym).each do |name, values|
+          raise Fabrication::InfiniteRecursionError, name if values.length > Fabrication::Config.recursion_limit
+        end
+      end
 
-  protected
+      protected
 
-  def raise_if_registered(name)
-    (raise Fabrication::DuplicateFabricatorError, name) if self[name]
-  end
+      def raise_if_registered(name)
+        (raise Fabrication::DuplicateFabricatorError, name) if self[name]
+      end
 
-  def store(name, aliases, options, &block)
-    schematic = schematics[name] = Fabrication::Schematic::Definition.new(name, options, &block)
-    aliases.each { |as| schematics[as.to_sym] = schematic }
+      def store(name, aliases, options, &block)
+        schematic = schematics[name] = Fabrication::Schematic::Definition.new(name, options, &block)
+        aliases.each { |as| schematics[as.to_sym] = schematic }
+      end
+    end
   end
-
 end

data/lib/fabrication/schematic/runner.rb

@@ -1,13 +1,16 @@
-class Fabrication::Schematic::Runner
+module Fabrication
+  module Schematic
+    class Runner
+      attr_accessor :klass
 
-  attr_accessor :klass
+      def initialize(klass)
+        self.klass = klass
+      end
 
-  def initialize(klass)
-    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, &block)
+        name = "#{klass.to_s.downcase.gsub(/::/, '_')}_#{name}"
+        Fabrication::Sequencer.sequence(name, start, &block)
+      end
+    end
   end
 end

data/lib/fabrication/sequencer.rb

@@ -1,29 +1,30 @@
-class Fabrication::Sequencer
+module Fabrication
+  class Sequencer
+    DEFAULT = :_default
 
-  DEFAULT = :_default
-
-  def self.sequence(name=DEFAULT, start=nil, &block)
-    idx = sequences[name] ||= start || Fabrication::Config.sequence_start
-    if block_given?
-      sequence_blocks[name] = block.to_proc
-    else
-      sequence_blocks[name] ||= lambda { |i| i }
-    end.call(idx).tap do
-      sequences[name] += 1
+    def self.sequence(name = DEFAULT, start = nil, &block)
+      idx = sequences[name] ||= start || Fabrication::Config.sequence_start
+      if block_given?
+        sequence_blocks[name] = block.to_proc
+      else
+        sequence_blocks[name] ||= ->(i) { i }
+      end.call(idx).tap do
+        sequences[name] += 1
+      end
     end
-  end
 
-  def self.sequences
-    @sequences ||= {}
-  end
+    def self.sequences
+      @sequences ||= {}
+    end
 
-  def self.sequence_blocks
-    @sequence_blocks ||= {}
-  end
+    def self.sequence_blocks
+      @sequence_blocks ||= {}
+    end
 
-  def self.reset
-    Fabrication::Config.sequence_start = nil
-    @sequences = nil
-    @sequence_blocks = nil
+    def self.reset
+      Fabrication::Config.sequence_start = nil
+      @sequences = nil
+      @sequence_blocks = nil
+    end
   end
 end

data/lib/fabrication/support.rb

@@ -1,70 +1,73 @@
-class Fabrication::Support
+module Fabrication
+  class Support
+    class << self
+      def fabricatable?(name)
+        Fabrication.manager[name] || class_for(name)
+      end
 
-  class << 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 class_for(class_or_to_s)
-      class_name = variable_name_to_class_name(class_or_to_s)
-      constantize(class_name)
-    rescue NameError => original_error
-      raise Fabrication::UnfabricatableError.new(class_or_to_s, original_error)
-    end
+            constant = constant.ancestors.inject do |const, ancestor|
+              break const    if ancestor == Object
+              break ancestor if ancestor.const_defined?(name, false)
 
-    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)
-          constant = constant.ancestors.inject do |const, ancestor|
-            break const    if ancestor == Object
-            break ancestor if ancestor.const_defined?(name, false)
-            const
+              const
+            end
+            constant.const_get(name, false)
           end
-          constant.const_get(name, false)
         end
       end
-    end
 
-    def extract_options!(args)
-      args.last.is_a?(::Hash) ? args.pop : {}
-    end
+      def extract_options!(args)
+        args.last.is_a?(::Hash) ? args.pop : {}
+      end
 
-    def variable_name_to_class_name(name)
-      name.to_s.gsub(/\/(.?)/){"::#{$1.upcase}"}.gsub(/(?:^|_)(.)/){$1.upcase}
-    end
+      def variable_name_to_class_name(name)
+        name.to_s.gsub(%r{/(.?)}) do
+          "::#{Regexp.last_match(1).upcase}"
+        end.gsub(/(?:^|_)(.)/) { Regexp.last_match(1).upcase }
+      end
 
-    def find_definitions
-      puts "DEPRECATION WARNING: Fabrication::Support.find_definitions has been replaced by Fabrication.manager.load_definitions and will be removed in 3.0.0."
-      Fabrication.manager.load_definitions
-    end
+      def find_definitions
+        puts 'DEPRECATION WARNING: Fabrication::Support.find_definitions has been replaced ' \
+          'by Fabrication.manager.load_definitions and will be removed in 3.0.0.'
+        Fabrication.manager.load_definitions
+      end
 
-    def hash_class
-      @hash_class ||= defined?(HashWithIndifferentAccess) ? HashWithIndifferentAccess : Hash
-    end
+      def hash_class
+        @hash_class ||= defined?(HashWithIndifferentAccess) ? HashWithIndifferentAccess : Hash
+      end
 
-    def singularize(string)
-      string.singularize
-    rescue
-      string.end_with?('s') ? string[0..-2] : string
-    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
+      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
-
 end