fabrication 2.20.1 → 3.0.0.beta.1

data/lib/fabrication/generator/mongoid.rb

@@ -1,15 +1,17 @@
-class Fabrication::Generator::Mongoid < Fabrication::Generator::Base
+module Fabrication
+  module Generator
+    class Mongoid < Fabrication::Generator::Base
+      def self.supports?(klass)
+        defined?(::Mongoid) && klass.ancestors.include?(::Mongoid::Document)
+      end
 
-  def self.supports?(klass)
-    defined?(Mongoid) && klass.ancestors.include?(Mongoid::Document)
-  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/sequel.rb

@@ -1,36 +1,38 @@
-class Fabrication::Generator::Sequel < Fabrication::Generator::Base
-
-  def initialize(klass)
-    super
-    load_instance_hooks
-  end
+module Fabrication
+  module Generator
+    class Sequel < Fabrication::Generator::Base
+      def initialize(klass)
+        super
+        load_instance_hooks
+      end
 
-  def self.supports?(klass)
-    defined?(Sequel) && klass.ancestors.include?(Sequel::Model)
-  end
+      def self.supports?(klass)
+        defined?(::Sequel) && 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) }
+      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
+          else
+            _instance.send("#{key}=", value)
+          end
         end
-      else
-        _instance.send("#{key}=", value)
       end
-    end
-  end
 
-  def persist
-    _instance.save(raise_on_failure: true)
-  end
+      def persist
+        _instance.save(raise_on_failure: true)
+      end
 
-  private
+      private
 
-  def load_instance_hooks
-    klass = _klass.respond_to?(:cti_base_model) ? _klass.cti_models.first : _klass
-    klass.plugin :instance_hooks unless klass.new.respond_to? :after_save_hook
+      def load_instance_hooks
+        klass = _klass.respond_to?(:cti_base_model) ? _klass.cti_models.first : _klass
+        klass.plugin :instance_hooks unless klass.new.respond_to? :after_save_hook
+      end
+    end
   end
-
 end

data/lib/fabrication/railtie.rb

@@ -9,9 +9,7 @@ module Fabrication
           config.generators
         end
 
-      unless generators.rails.has_key?(:fixture_replacement)
-        generators.fixture_replacement :fabrication
-      end
+      generators.fixture_replacement :fabrication unless generators.rails.key?(:fixture_replacement)
     end
   end
 end

data/lib/fabrication/schematic/attribute.rb

@@ -1,65 +1,72 @@
-class Fabrication::Schematic::Attribute
-
-  attr_accessor :klass, :name, :value
-  attr_writer :params
-
-  def initialize(klass, name, value, params={}, &block)
-    self.klass = klass
-    self.name = name
-    self.params = params
-    self.value = value.nil? ? block : value
-  end
-
-  def params
-    @params ||= {}
-  end
-
-  def transient!
-    params[:transient] = true
-  end
-
-  def transient?
-    params[:transient]
-  end
-
-  def processed_value(processed_attributes)
-    if process_count
-      (1..process_count).map { |i| execute(processed_attributes, i, &value) }
-    elsif value_proc?
-      execute(processed_attributes, &value)
-    else
-      value
+module Fabrication
+  module Schematic
+    class Attribute
+      attr_accessor :klass, :name, :value
+      attr_writer :params
+
+      def initialize(klass, name, value, params = {}, &block)
+        self.klass = klass
+        self.name = name
+        self.params = params
+        self.value = value.nil? ? block : value
+      end
+
+      def params
+        @params ||= {}
+      end
+
+      def transient!
+        params[:transient] = true
+      end
+
+      def transient?
+        params[:transient]
+      end
+
+      def processed_value(processed_attributes)
+        if process_count
+          (1..process_count).map { |i| execute(processed_attributes, i, &value) }
+        elsif value_proc?
+          execute(processed_attributes, &value)
+        else
+          value
+        end
+      end
+
+      def value_static?
+        !value_proc?
+      end
+
+      def value_proc?
+        value.is_a?(Proc)
+      end
+
+      private
+
+      def execute(*args, &block)
+        Fabrication::Schematic::Runner.new(klass).instance_exec(*args, &block)
+      end
+
+      def process_count
+        count || rand || rand_range
+      end
+
+      def count
+        params[:count]
+      end
+
+      def rand
+        return unless params[:rand]
+
+        range = params[:rand]
+        range = 1..range unless range.is_a? Range
+
+        Kernel.rand(range)
+      end
+
+      def rand_range
+        Kernel.rand((params[:start_range]..params[:end_range])) if params[:start_range] && params[:end_range]
+      end
     end
   end
-
-  def value_static?; !value_proc? end
-  def value_proc?; Proc === value end
-
-  private
-
-  def execute(*args, &block)
-    Fabrication::Schematic::Runner.new(klass).instance_exec(*args, &block)
-  end
-
-  def process_count
-    count || rand || rand_range
-  end
-
-  def count
-    params[:count]
-  end
-
-  def rand
-    return unless params[:rand]
-
-    range = params[:rand]
-    range = 1..range unless range.is_a? Range
-
-    Kernel.rand(range)
-  end
-
-  def rand_range
-    Kernel.rand((params[:start_range]..params[:end_range])) if params[:start_range] && params[:end_range]
-  end
-
 end

data/lib/fabrication/schematic/definition.rb

@@ -1,164 +1,170 @@
-class Fabrication::Schematic::Definition
-
-  GENERATORS = [
-    Fabrication::Generator::ActiveRecord,
-    Fabrication::Generator::DataMapper,
-    Fabrication::Generator::Sequel,
-    Fabrication::Generator::Mongoid,
-    Fabrication::Generator::Base
-  ]
-
-  attr_accessor :name, :options, :block
-  def initialize(name, options={}, &block)
-    self.name = name
-    self.options = options
-    self.block = block
-  end
+module Fabrication
+  module Schematic
+    class Definition
+      GENERATORS = [
+        Fabrication::Generator::ActiveRecord,
+        Fabrication::Generator::Sequel,
+        Fabrication::Generator::Mongoid,
+        Fabrication::Generator::Base
+      ].freeze
+
+      attr_accessor :name, :options, :block
+
+      def initialize(name, options = {}, &block)
+        self.name = name
+        self.options = options
+        self.block = block
+      end
 
-  def process_block(&block)
-    Fabrication::Schematic::Evaluator.new.process(self, &block) if block_given?
-  end
+      def process_block(&block)
+        Fabrication::Schematic::Evaluator.new.process(self, &block) if block_given?
+      end
 
-  def attribute(name)
-    attributes.detect { |a| a.name == name }
-  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)
-    if index = attributes.index { |a| a.name == attribute.name }
-      attribute.transient! if attributes[index].transient?
-      attributes[index] = attribute
-    else
-      attributes << attribute
-    end
-  end
+      def append_or_update_attribute(attribute_name, value, params = {}, &block)
+        attribute = Fabrication::Schematic::Attribute.new(klass, attribute_name, value, params, &block)
+        index = attributes.index { |a| a.name == attribute.name }
 
-  attr_writer :attributes
-  def attributes
-    load_body
-    @attributes ||= []
-  end
+        if index
+          attribute.transient! if attributes[index].transient?
+          attributes[index] = attribute
+        else
+          attributes << attribute
+        end
+      end
 
-  attr_writer :callbacks
-  def callbacks
-    load_body
-    @callbacks ||= {}
-  end
+      attr_writer :attributes, :callbacks
 
-  def generator
-    @generator ||= Fabrication::Config.generator_for(GENERATORS, klass)
-  end
+      def attributes
+        load_body
+        @attributes ||= []
+      end
 
-  def sorted_attributes
-    attributes.select(&:value_static?) + attributes.select(&:value_proc?)
-  end
+      def callbacks
+        load_body
+        @callbacks ||= {}
+      end
 
-  def build(overrides={}, &block)
-    Fabrication.manager.prevent_recursion!
-    if Fabrication.manager.to_params_stack.any?
-      to_params(overrides, &block)
-    else
-      begin
-        Fabrication.manager.build_stack << name
-        merge(overrides, &block).instance_eval do
-          generator.new(klass).build(sorted_attributes, callbacks)
+      def generator
+        @generator ||= Fabrication::Config.generator_for(GENERATORS, klass)
+      end
+
+      def sorted_attributes
+        attributes.select(&:value_static?) + attributes.select(&:value_proc?)
+      end
+
+      def build(overrides = {}, &block)
+        Fabrication.manager.prevent_recursion!
+        if Fabrication.manager.to_params_stack.any?
+          to_params(overrides, &block)
+        else
+          begin
+            Fabrication.manager.build_stack << name
+            merge(overrides, &block).instance_eval do
+              generator.new(klass).build(sorted_attributes, callbacks)
+            end
+          ensure
+            Fabrication.manager.build_stack.pop
+          end
         end
-      ensure
-        Fabrication.manager.build_stack.pop
       end
-    end
-  end
 
-  def fabricate(overrides={}, &block)
-    Fabrication.manager.prevent_recursion!
-    if Fabrication.manager.build_stack.any?
-      build(overrides, &block)
-    elsif Fabrication.manager.to_params_stack.any?
-      to_params(overrides, &block)
-    else
-      begin
-        Fabrication.manager.create_stack << name
+      def fabricate(overrides = {}, &block)
+        Fabrication.manager.prevent_recursion!
+        if Fabrication.manager.build_stack.any?
+          build(overrides, &block)
+        elsif Fabrication.manager.to_params_stack.any?
+          to_params(overrides, &block)
+        else
+          begin
+            Fabrication.manager.create_stack << name
+            merge(overrides, &block).instance_eval do
+              generator.new(klass).create(sorted_attributes, callbacks)
+            end
+          ensure
+            Fabrication.manager.create_stack.pop
+          end
+        end
+      end
+
+      def to_params(overrides = {}, &block)
+        Fabrication.manager.prevent_recursion!
+        Fabrication.manager.to_params_stack << name
         merge(overrides, &block).instance_eval do
-          generator.new(klass).create(sorted_attributes, callbacks)
+          generator.new(klass).to_params(sorted_attributes)
         end
       ensure
-        Fabrication.manager.create_stack.pop
+        Fabrication.manager.to_params_stack.pop
       end
-    end
-  end
 
-  def to_params(overrides={}, &block)
-    Fabrication.manager.prevent_recursion!
-    Fabrication.manager.to_params_stack << name
-    merge(overrides, &block).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
+          generator.new(klass).to_hash(sorted_attributes, callbacks)
+        end
+      end
 
-  def to_attributes(overrides={}, &block)
-    merge(overrides, &block).instance_eval do
-      generator.new(klass).to_hash(sorted_attributes, callbacks)
-    end
-  end
+      def initialize_copy(original)
+        self.callbacks = {}
+        original.callbacks.each do |type, callbacks|
+          self.callbacks[type] = callbacks.clone
+        end
 
-  def initialize_copy(original)
-    self.callbacks = {}
-    original.callbacks.each do |type, callbacks|
-      self.callbacks[type] = callbacks.clone
-    end
+        self.attributes = original.attributes.clone
+      end
 
-    self.attributes = original.attributes.clone
-  end
+      def generate_value(name, params)
+        if params[:count] || params[:rand]
+          name = Fabrication::Support.singularize(name.to_s)
+          proc { Fabricate.build(params[:fabricator] || name) }
+        else
+          proc { Fabricate(params[:fabricator] || name) }
+        end
+      end
 
-  def generate_value(name, params)
-    if params[:count] || params[:rand]
-      name = Fabrication::Support.singularize(name.to_s)
-      proc { Fabricate.build(params[:fabricator] || name) }
-    else
-      proc { Fabricate(params[:fabricator] || name) }
-    end
-  end
+      def merge(overrides = {}, &block)
+        clone.tap do |definition|
+          definition.process_block(&block)
+          overrides.each do |name, value|
+            definition.append_or_update_attribute(name.to_sym, value)
+          end
+        end
+      end
 
-  def merge(overrides={}, &block)
-    clone.tap do |definition|
-      definition.process_block(&block)
-      overrides.each do |name, value|
-        definition.append_or_update_attribute(name.to_sym, value)
+      def klass
+        @klass ||= Fabrication::Support.class_for(
+          options[:class_name] ||
+            parent&.klass ||
+            options[:from] ||
+            name
+        )
       end
-    end
-  end
 
-  def klass
-    @klass ||= Fabrication::Support.class_for(
-      options[:class_name] ||
-        (parent && parent.klass) ||
-        options[:from] ||
-        name
-    )
-  end
+      protected
+
+      def loaded?
+        !!(@loaded ||= nil)
+      end
 
-  protected
+      def load_body
+        return if loaded?
 
-  def loaded?
-    !!(@loaded ||= nil)
-  end
+        @loaded = true
 
-  def load_body
-    return if loaded?
-    @loaded = true
+        if parent
+          merge_result = parent.merge(&block)
+          @attributes = merge_result.attributes
+          @callbacks = merge_result.callbacks
+        else
+          process_block(&block)
+        end
+      end
 
-    if parent
-      merge_result = parent.merge(&block)
-      @attributes = merge_result.attributes
-      @callbacks = merge_result.callbacks
-    else
-      process_block(&block)
+      def parent
+        @parent ||= Fabrication.manager[options[:from].to_s] if options[:from]
+      end
     end
   end
-
-  def parent
-    @parent ||= Fabrication.manager[options[:from].to_s] if options[:from]
-  end
 end