fabrication 2.20.2 → 2.23.0

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,79 @@
-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_string = name.to_s
 
-    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
+        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 hash_class
-      @hash_class ||= defined?(HashWithIndifferentAccess) ? HashWithIndifferentAccess : Hash
-    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 singularize(string)
-      string.singularize
-    rescue
-      string.end_with?('s') ? string[0..-2] : string
-    end
+      def hash_class
+        @hash_class ||= defined?(HashWithIndifferentAccess) ? HashWithIndifferentAccess : Hash
+      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
+      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
-
 end

data/lib/fabrication/syntax/make.rb

@@ -1,6 +1,5 @@
 module Fabrication
   module Syntax
-
     # Extends Fabrication to provide make/make! class methods, which are
     # shortcuts for Fabricate.build/Fabricate.
     #

data/lib/fabrication/transform.rb

@@ -1,39 +1,37 @@
-class Fabrication::Transform
-
-  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)) }
+module Fabrication
+  class Transform
+    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)) }
+      end
+
+      def clear_all
+        @transforms = nil
+        @overrides = nil
+      end
+
+      def define(attribute, transform)
+        transforms[attribute] = transform
+      end
+
+      def only_for(schematic, attribute, transform)
+        overrides[schematic] = (overrides[schematic] || {}).merge!(attribute => transform)
+      end
+
+      private
+
+      def overrides
+        @overrides ||= {}
+      end
+
+      def apply_transform(schematic, attribute, value)
+        overrides.fetch(schematic, transforms)[attribute].call(value)
+      end
+
+      def transforms
+        @transforms ||= Hash.new(->(value) { value })
+      end
     end
-
-    def clear_all
-      @transforms = nil
-      @overrides = nil
-    end
-
-    def define(attribute, transform)
-      transforms[attribute] = transform
-    end
-
-    def only_for(schematic, attribute, transform)
-      overrides[schematic] = (overrides[schematic] || {}).merge!(attribute => transform)
-    end
-
-    private
-
-    def overrides
-      @overrides ||= {}
-    end
-
-    def apply_transform(schematic, attribute, value)
-      overrides.fetch(schematic, transforms)[attribute].call(value)
-    end
-
-    def transforms
-      @transforms ||= Hash.new(lambda {|value| value})
-    end
-
   end
-
 end

data/lib/fabrication/version.rb

@@ -1,3 +1,3 @@
 module Fabrication
-  VERSION = '2.20.2'
+  VERSION = '2.23.0'.freeze
 end

data/lib/fabrication.rb

@@ -33,7 +33,6 @@ module Fabrication
     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'
   end
@@ -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/rails/generators/fabrication/cucumber_steps/cucumber_steps_generator.rb

@@ -3,13 +3,12 @@ require 'rails/generators/base'
 module Fabrication
   module Generators
     class CucumberStepsGenerator < Rails::Generators::Base
-
       def generate
-        template 'fabrication_steps.rb', "features/step_definitions/fabrication_steps.rb"
+        template 'fabrication_steps.rb', 'features/step_definitions/fabrication_steps.rb'
       end
 
       def self.source_root
-        @_fabrication_source_root ||= File.expand_path(File.join(File.dirname(__FILE__), 'templates'))
+        @source_root ||= File.expand_path(File.join(File.dirname(__FILE__), 'templates'))
       end
     end
   end

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

@@ -7,44 +7,44 @@ def with_ivars(fabricator)
   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
+  Fabrication::Cucumber::Fabrications[model.singularize.gsub(/\W+/, '_').downcase] = @they.last
 end
 
-Given /^(\d+) ([^"]*)$/ do |count, model_name|
+Given(/^(\d+) ([^"]*)$/) do |count, model_name|
   with_ivars Fabrication::Cucumber::StepFabricator.new(model_name) do |fab|
     fab.n(count.to_i)
   end
 end
 
-Given /^the following ([^"]*):$/ do |model_name, table|
+Given(/^the following ([^"]*):$/) do |model_name, table|
   with_ivars Fabrication::Cucumber::StepFabricator.new(model_name) do |fab|
     fab.from_table(table)
   end
 end
 
-Given /^that ([^"]*) has the following ([^"]*):$/ do |parent, child, table|
-  with_ivars Fabrication::Cucumber::StepFabricator.new(child, :parent => parent) do |fab|
+Given(/^that ([^"]*) has the following ([^"]*):$/) do |parent, child, table|
+  with_ivars Fabrication::Cucumber::StepFabricator.new(child, parent: 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|
+Given(/^that ([^"]*) has (\d+) ([^"]*)$/) do |parent, count, child|
+  with_ivars Fabrication::Cucumber::StepFabricator.new(child, parent: parent) do |fab|
     fab.n(count.to_i)
   end
 end
 
-Given /^(?:that|those) (.*) belongs? to that (.*)$/ do |children, parent|
+Given(/^(?:that|those) (.*) belongs? to that (.*)$/) do |children, parent|
   with_ivars Fabrication::Cucumber::StepFabricator.new(parent) do |fab|
     fab.has_many(children)
   end
 end
 
-Then /^I should see (\d+) ([^"]*) in the database$/ do |count, model_name|
+Then(/^I should see (\d+) ([^"]*) in the database$/) do |count, model_name|
   expect(Fabrication::Cucumber::StepFabricator.new(model_name).klass.count).to eq(count.to_i)
 end
 
-Then /^I should see the following (.*) in the database:$/ do |model_name, table|
+Then(/^I should see the following (.*) in the database:$/) do |model_name, table|
   klass = Fabrication::Cucumber::StepFabricator.new(model_name).klass
   expect(klass.where(table.rows_hash.symbolize_keys).count).to eq(1)
 end

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

@@ -3,17 +3,23 @@ require 'rails/generators/named_base'
 module Fabrication
   module Generators
     class ModelGenerator < Rails::Generators::NamedBase
-      argument :attributes, :type => :array, :default => [], :banner => "field:type field:type"
-      class_option :dir, :type => :string, :default => "spec/fabricators", :desc => "The directory where the fabricators should go"
-      class_option :extension, :type => :string, :default => "rb", :desc => "file extension name"
+      argument :attributes, type: :array, default: [], banner: 'field:type field:type'
+      class_option :dir, type: :string, default: 'spec/fabricators',
+                         desc: 'The directory where the fabricators should go'
+      class_option :extension, type: :string, default: 'rb', desc: 'file extension name'
 
       def create_fabrication_file
         copy_attributes_from_model if attributes.empty?
-        template 'fabricator.erb', File.join(options[:dir], "#{singular_table_name}_fabricator.#{options[:extension].to_s}")
+        template_file = File.join(
+          options[:dir],
+          class_path,
+          "#{file_name}_fabricator.#{options[:extension]}"
+        )
+        template 'fabricator.erb', template_file
       end
 
       def self.source_root
-        @_fabrication_source_root ||= File.expand_path(File.join(File.dirname(__FILE__), 'templates'))
+        @source_root ||= File.expand_path(File.join(File.dirname(__FILE__), 'templates'))
       end
 
       private
@@ -21,14 +27,13 @@ module Fabrication
       def copy_attributes_from_model
         model = class_name.constantize
         if defined?(ActiveRecord) && model < ActiveRecord::Base
-          self.attributes = model.columns_hash.map { |name, column|
+          self.attributes = model.columns_hash.map do |name, column|
             Rails::Generators::GeneratedAttribute.new(name, column.type)
-          }
+          end
         end
-      rescue
+      rescue StandardError
         # no table? no problem!
       end
-
     end
   end
 end

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

@@ -1,6 +1,10 @@
+<% if namespaced? -%>
+Fabricator(<%= ":#{singular_name}, from: '#{namespace}::#{class_name}'" %>) do
+<% else -%>
 Fabricator(<%= class_name.match(/::/) ? "'#{class_name}'" : ":#{singular_name}" %>) do
+<% end -%>
 <% width = attributes.map{|a| a.name.size }.max.to_i -%>
 <% attributes.each do |attribute| -%>
   <%= "%-#{width}s %s" % [attribute.name, attribute.default.inspect] %>
 <% end -%>
-end
+end

data/lib/tasks/defined_fabricators.rake

@@ -1,30 +1,30 @@
 namespace :fabrication do
-  desc "Display all registered fabricators by class"
-  task :list => :environment do
+  desc 'Display all registered fabricators by class'
+  task list: :environment do
     Fabrication.manager.load_definitions if Fabrication.manager.empty?
 
     if Fabrication.manager.schematics.none?
-      puts "No fabricators found"
+      puts 'No fabricators found'
       next
     end
 
-    groups = Fabrication.manager.schematics.group_by do |name, fabdef|
+    schematic_groups = Fabrication.manager.schematics.group_by do |_name, fabdef|
       fabdef.klass.name
     end
 
     fabricators = {}
-    groups.sort_by { |klass, _| klass }.each do |klass, groups|
-      fabricators[klass] = groups.map(&:first).sort.join(", ")
+    schematic_groups.sort_by { |klass, _| klass }.each do |klass, groups|
+      fabricators[klass] = groups.map(&:first).sort.join(', ')
     end
 
-    class_width = fabricators.keys.max_by { |v| v.size }.size + 3 # padding
-    names_width = fabricators.values.max_by { |v| v.size }.size
+    class_width = fabricators.keys.max_by(&:size).size + 3 # padding
+    names_width = fabricators.values.max_by(&:size).size
     say = lambda do |f1, f2|
       printf "%-#{class_width}s%-#{names_width}s\n", f1, f2
     end
 
-    say["Class", "Fabricator"]
-    puts "-" * (names_width + class_width)
-    fabricators.each { |klass, names| say[klass,names] }
+    say['Class', 'Fabricator']
+    puts '-' * (names_width + class_width)
+    fabricators.each { |klass, names| say[klass, names] }
   end
 end