dirty_seed 0.1.7 → 0.1.8

data/lib/dirty_seed/assigners/min_max_helper.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module DirtySeed
+  module Assigners
+    # Helps with min and max validations
+    module MinMaxHelper
+      # Returns the minimal value
+      # @return [Integer, Float]
+      def min
+        @min ||= define_min_and_max && @min
+      end
+
+      # Returns the maximal value
+      # @return [Integer, Float]
+      def max
+        @max ||= define_min_and_max && @max
+      end
+
+      # Defines min and max depending on validator
+      # @return [void]
+      def define_min_and_max
+        @min = acceptable_min
+        @max = acceptable_max
+
+        # If necessary, adjust a value depending on the other
+        @min ||= floor
+        @max ||= @min + ceiling || ceiling # rubocop:disable Naming/MemoizedInstanceVariableName
+      end
+
+      # Returns default min depending on type
+      # @return [Integer, Float]
+      def floor # rubocop:disable Metrics/CyclomaticComplexity
+        case type
+        when :string then 1
+        when :integer then @max&.negative? ? @max * 2 : 0
+        when :float then @max&.negative? ? @max * 2 : 0.0
+        end
+      end
+
+      # Returns default max depending on type
+      # @return [Integer, Float]
+      def ceiling
+        case type
+        when :string then 50
+        when :integer then 42
+        when :float then 42.0
+        end
+      end
+
+      # Returns the validator that validate min and/or max
+      def min_max_validator
+        validators.find { |validator| validator.is_a? validator_class }
+      end
+
+      # Returns the validator class depending on the type
+      def validator_class
+        case type
+        when :string then ActiveRecord::Validations::LengthValidator
+        when :integer, :float then ActiveModel::Validations::NumericalityValidator
+        end
+      end
+
+      # Returns a value representing the minimal acceptable value
+      # @return [Integer, Float]
+      def acceptable_min
+        return unless min_max_validator
+
+        min_max_validator.options[:in]&.min || type_related_acceptable_min
+      end
+
+      # Returns a value representing the minimal acceptable value depending on type
+      # @return [Integer, Float]
+      def type_related_acceptable_min
+        case type
+        when :string
+          min_max_validator.options[:minimum] || min_max_validator.options[:is]
+        when :integer, :float
+          min_max_validator.options[:greater_than]&.+(gap) ||
+            min_max_validator.options[:greater_than_or_equal_to]
+        end
+      end
+
+      # Returns a value representing the maximal acceptable value
+      # @return [Integer, Float]
+      def acceptable_max
+        return unless min_max_validator
+
+        min_max_validator.options[:in]&.max || type_related_acceptable_max
+      end
+
+      # Returns a value representing the maximal acceptable value depending on type
+      # @return [Integer, Float]
+      def type_related_acceptable_max
+        case type
+        when :string
+          min_max_validator.options[:maximum] || min_max_validator.options[:is]
+        when :integer, :float
+          min_max_validator.options[:less_than]&.-(gap) ||
+            min_max_validator.options[:less_than_or_equal_to]
+        end
+      end
+
+      # Defines the gap to add to min when "greater_than" or to substract to max when "less_than"
+      #   For example if type is :float and value should be greater_than 0, then the min is 0.01
+      #     and if the value should be lesser_than 1, then the max is 0.99
+      # @return [Integer, Float]
+      def gap
+        case type
+        when :integer then 1
+        when :float then 0.01
+        end
+      end
+    end
+  end
+end

data/lib/dirty_seed/assigners/{dirty_number.rb → number.rb}

@@ -3,12 +3,12 @@
 module DirtySeed
   module Assigners
     # Draws an integer matching validators
-    class DirtyNumber < DirtyAssigner
+    class Number < Assigner
       attr_reader :min, :max
 
       # Returns an value matching all validators
       # @return [Integer, Float]
-      def define_value
+      def value
         unless min && max
           define_min_and_max
           adjust_values

data/lib/dirty_seed/assigners/string.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module DirtySeed
+  module Assigners
+    # Draws a String matching validators
+    class String < Assigner
+      include MinMaxHelper
+
+      # Returns a value matching all validators
+      # @return [String]
+      def value
+        regex_value || default
+      end
+
+      private
+
+      # Returns a standard string
+      # @return [String]
+      def default
+        faker_value(
+          category: :Lorem,
+          method: :paragraph_by_chars,
+          options: { number: rand(min..max), supplemental: false }
+        )
+      end
+
+      # Returns a value matching the pattern
+      # @note Rescue from unreadable regex
+      # @return [String]
+      def regex_value
+        return unless regex
+
+        regex.random_example
+      rescue RegexpExamples::IllegalSyntaxError
+        nil
+      end
+    end
+  end
+end

data/lib/dirty_seed/assigners/{dirty_time.rb → time.rb}

@@ -3,10 +3,10 @@
 module DirtySeed
   module Assigners
     # Draws a value matching validators
-    class DirtyTime < DirtyAssigner
+    class Time < Assigner
       # Returns a value matching all validators
       # @return [Time]
-      def define_value
+      def value
         ::Faker::Time.between(from: DateTime.now - 42, to: DateTime.now + 42)
       end
     end

data/lib/dirty_seed/{dirty_association.rb → association.rb}

@@ -2,32 +2,21 @@
 
 module DirtySeed
   # Represents an Active Record association
-  class DirtyAssociation
+  class Association
     extend ::DirtySeed::MethodMissingHelper
     forward_missing_methods_to :reflections
 
-    attr_reader :dirty_model, :reflection
+    attr_reader :model, :reflection
 
     # Initializes an instance
-    # @param dirty_model [DirtySeed::DirtyModel]
+    # @param model [DirtySeed::Model]
     # @param reflection [ActiveRecord::Reflection::BelongsToReflection]
-    # @return [DirtySeed::DirtyAssociation]
-    def initialize(dirty_model, reflection)
-      @dirty_model = dirty_model
+    # @return [DirtySeed::Association]
+    def initialize(model, reflection)
+      @model = model
       @reflection = reflection
     end
 
-    # Assigns a random value to the association
-    # @param instance [Object] an instance of a class inheriting from ApplicationRecord
-    # @return [void]
-    def assign_value(instance)
-      return if associated_models.empty?
-
-      instance.public_send(:"#{name}=", value)
-    rescue ArgumentError => e
-      @errors << e
-    end
-
     # Returns a random instance matching the reflection
     # @return [Object] an instance of a class inheriting from ApplicationRecord
     def value

data/lib/dirty_seed/attribute.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module DirtySeed
+  # Represents an Active Record attribute
+  class Attribute
+    extend ::DirtySeed::MethodMissingHelper
+    forward_missing_methods_to :column
+
+    attr_reader :model, :column
+
+    TYPE_SYMMETRIES = {
+      binary: :integer,
+      datetime: :time,
+      decimal: :float,
+      text: :string
+    }.freeze
+    private_constant :TYPE_SYMMETRIES
+
+    # Initializes an instance
+    # @param model [DirtySeed::Model]
+    # @param column [ActiveRecord::ConnectionAdapters::Column]
+    # @return [DirtySeed::Attribute]
+    def initialize(model, column)
+      @model = model
+      @column = column
+    end
+
+    # Returns a value matching type and validators
+    # @return [Object, nil]
+    def value
+      assigner.value
+    end
+
+    # Returns the attribute assigner
+    # @return [DirtySeed::Assigners::Assigner]
+    def assigner
+      @assigner ||= DirtySeed::Assigners::Base.new(self)
+    end
+
+    # Returns attribute name
+    # @return [Symbol]
+    def name
+      @name ||= column.name.to_sym
+    end
+
+    # Returns attribute type
+    # @return [Symbol]
+    def type
+      @type ||=
+        TYPE_SYMMETRIES[column.sql_type_metadata.type] || column.sql_type_metadata.type
+    end
+
+    # Returns an validators related to the current attribute
+    # @return [Array<ActiveModel::Validations::EachValidators>]
+    def validators
+      @validators ||=
+        model.validators.select do |validator|
+          validator.attributes.include? name
+        end
+    end
+  end
+end

data/lib/dirty_seed/data_model.rb

@@ -4,11 +4,10 @@ module DirtySeed
   # Represents the data model
   class DataModel
     include Singleton
-    attr_accessor :logs
 
     class << self
       # Defines class methods forwarding to instance methods
-      %i[dirty_models active_record_models print_logs reset].each do |method_name|
+      %i[active_record_models models print_logs reset].each do |method_name|
         define_method(method_name) { instance.public_send(method_name) }
       end
 
@@ -20,19 +19,19 @@ module DirtySeed
       end
 
       # Returns dirty model if method_name matches its name
-      # @return [DirtySeed::DirtyModel]
+      # @return [DirtySeed::Model]
       # @raise [NoMethodError] if method_name does not match any dirty model
       def method_missing(method_name, *args, &block)
-        dirty_models.find do |dirty_model|
-          dirty_model.name.underscore.to_sym == method_name
+        models.find do |model|
+          model.name.underscore.to_sym == method_name
         end || super
       end
 
       # Returns true if method_name matches a dirty model name
       # @return [Boolean]
       def respond_to_missing?(method_name, include_private = false)
-        dirty_models.any? do |dirty_model|
-          dirty_model.name.underscore.to_sym == method_name
+        models.any? do |model|
+          model.name.underscore.to_sym == method_name
         end || super
       end
     end
@@ -41,7 +40,6 @@ module DirtySeed
     # @return [DirtySeed::DataModel]
     def initialize
       Rails.application.eager_load!
-      @logs = {}
     end
 
     # Seeds the database with dirty instances
@@ -50,16 +48,16 @@ module DirtySeed
     def seed(count)
       # check if ApplicationRecord is defined first (or raise error)
       ::ApplicationRecord &&
-        dirty_models.each { |dirty_model| dirty_model.seed(count) }
+        models.each { |model| model.seed(count) }
       print_logs
     end
 
     # Returns dirty models
-    # @return [Array<DirtySeed::DirtyModel>]
-    def dirty_models
-      @dirty_models ||=
+    # @return [Array<DirtySeed::Model>]
+    def models
+      @models ||=
         active_record_models.map do |active_record_model|
-          DirtySeed::DirtyModel.new(active_record_model)
+          DirtySeed::Model.new(active_record_model)
         end
     end
 
@@ -79,10 +77,11 @@ module DirtySeed
     # Prints logs in the console
     # @return [void]
     def print_logs
-      dirty_models.sort_by(&:name).each do |dirty_model|
-        puts dirty_model.name
-        puts "  created: #{dirty_model.seeded}"
-        puts "  errors: #{dirty_model.errors.join(', ')}" if dirty_model.errors.any?
+      puts ''
+      models.sort_by(&:name).each do |model|
+        puts model.name
+        puts "  seeded: #{model.instances.count}"
+        puts "  errors: #{model.errors.join(', ')}" if model.errors.any?
       end
     end
 
@@ -90,7 +89,7 @@ module DirtySeed
     # @return [void]
     def reset
       @logs = nil
-      @dirty_models = nil
+      @models = nil
       @active_record_models = nil
     end
   end

data/lib/dirty_seed/method_missing_helper.rb

@@ -24,7 +24,7 @@ module DirtySeed
 
     # Defines missing_method method so it returns the adressee or calls super
     # @example
-    #   calling #name on a DirtyModel instance will call name on its @model object
+    #   calling #name on a Model instance will call name on its @model object
     # @return [void]
     def define_method_missing
       define_method :method_missing do |method_name, *args, &block|

data/lib/dirty_seed/{dirty_model.rb → model.rb}

@@ -2,12 +2,11 @@
 
 module DirtySeed
   # Represents an Active Record model
-  class DirtyModel
+  class Model
     extend ::DirtySeed::MethodMissingHelper
     forward_missing_methods_to :model
 
-    attr_reader :model, :instances, :seeded
-    attr_writer :errors
+    attr_reader :model, :instances
 
     PROTECTED_COLUMNS = %w[
       id
@@ -23,41 +22,105 @@ module DirtySeed
 
     # Initializes an instance
     # @param model [Class] a class inheriting from ApplicationRecord
-    # @return [DirtySeed::DirtyModel]
+    # @return [DirtySeed::Model]
     def initialize(model)
       @model = model
       @instances = []
-      @seeded = 0
       @errors = []
     end
 
-    # Creates instances for each model
+    # Creates records
     # @param count [Integer]
-    # @return [void]
+    # @return [Array<Object>]
     def seed(count)
-      count.times { create_instance }
-      @instances
+      puts "Seeding #{name.underscore.pluralize}"
+      @count = count
+      create_records
+    rescue ActiveRecord::ActiveRecordError => e
+      @errors << e
+    ensure
+      instances
+    end
+
+    # Creates records
+    # @return [void]
+    def create_records
+      data = params_collection
+      @count.times do |i|
+        instance = model.new(data[i])
+        save(instance)
+      end
+      puts ''
+    end
+
+    # Tries to save instance in database
+    #   Populates instances and errors and log message
+    # @return [void]
+    def save(instance)
+      if instance.save
+        print '.'
+        @instances << instance
+      else
+        print '!'
+        @errors << instance.errors.full_messages
+      end
+    end
+
+    # Generate records params
+    # @return [Array<Hash>] where Hash is params for one record
+    def params_collection
+      data = Hash[attributes_collection + associations_collection]
+      data.values.transpose.map { |vs| data.keys.zip(vs).to_h }
+    end
+
+    # Generate attributes params
+    #   Each sub-array contains the attribute name and a collection of values
+    # @return [Array<Array>]
+    # @example
+    #   [
+    #     ["a_string", ["foo", "bar"]],
+    #     [an_integer, [1, 2]]
+    #   ]
+    def attributes_collection
+      attributes.map do |attribute|
+        Faker::UniqueGenerator.clear
+        [attribute.name, @count.times.map { attribute.value }]
+      end
+    end
+
+    # Generate associations params
+    #   Each sub-array contains the association name and a collection of values
+    # @return [Array<Array>]
+    # @example
+    #   [
+    #     ["alfa", [#<Alfa>, #<Alfa>]],
+    #     ["bravo", [#<Bravo>, #<Bravo>]]
+    #   ]
+    def associations_collection
+      associations.map do |association|
+        [association.name, @count.times.map { association.value }]
+      end
     end
 
     # Returns models where models are associated to the current model through a has_many or has_one associations
     # @return [Array<Class>] ActiveRecord models
     def associated_models
-      dirty_associations.map(&:associated_models).flatten
+      associations.map(&:associated_models).flatten
     end
 
     # Returns an dirty associations representing the self.model belongs_to associations
-    # @return [Array<DirtySeed::DirtyAssociation>]
-    def dirty_associations
+    # @return [Array<DirtySeed::Association>]
+    def associations
       included_reflections.map do |reflection|
-        DirtySeed::DirtyAssociation.new(self, reflection)
+        DirtySeed::Association.new(self, reflection)
       end
     end
 
     # Returns model attributes
-    # @return [Array<DirtySeed::DirtyAttribute>]
-    def dirty_attributes
+    # @return [Array<DirtySeed::Attribute>]
+    def attributes
       included_columns.map do |column|
-        DirtySeed::DirtyAttribute.new(self, column)
+        DirtySeed::Attribute.new(self, column)
       end
     end
 
@@ -69,21 +132,6 @@ module DirtySeed
 
     private
 
-    # Creates an instance
-    # @return [void]
-    def create_instance
-      @instances << instance = model.new
-      dirty_associations.each { |dirty_association| dirty_association.assign_value(instance) }
-      dirty_attributes.each { |dirty_attribute| dirty_attribute.assign_value(instance) }
-      if instance.save
-        @seeded += 1
-      else
-        @errors << instance.errors.full_messages
-      end
-    rescue ActiveRecord::ActiveRecordError => e
-      errors << e
-    end
-
     # Returns columns that should be treated as regular attributes
     # @return [Array<ActiveRecord::ConnectionAdapters::Column>]
     def included_columns
@@ -99,8 +147,8 @@ module DirtySeed
     # @return [Array<String>]
     def reflection_related_attributes
       all_reflection_related_attributes =
-        dirty_associations.map do |dirty_association|
-          [dirty_association.attribute, dirty_association.type_key].compact
+        associations.map do |association|
+          [association.attribute, association.type_key].compact
         end
       all_reflection_related_attributes.flatten.map(&:to_s)
     end