dirty_seed 0.1.4

data/lib/dirty_seed/dirty_association.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module DirtySeed
+  # Represents an Active Record association
+  class DirtyAssociation
+    extend ::DirtySeed::MethodMissingHelper
+    forward_missing_methods_to :reflections
+
+    attr_reader :dirty_model, :reflection
+
+    # Initializes an instance
+    # @param dirty_model [DirtySeed::DirtyModel]
+    # @param reflection [ActiveRecord::Reflection::BelongsToReflection]
+    # @return [DirtySeed::DirtyAssociation]
+    def initialize(dirty_model, reflection)
+      @dirty_model = dirty_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
+      random_model = associated_models.sample
+      random_id = random_model.pluck(:id).sample
+      random_model.find_by(id: random_id)
+    end
+
+    # Returns the reflection name
+    # @return [String]
+    def name
+      reflection.name
+    end
+
+    # Returns the attribute containing the foreign key
+    # @return [Symbol]
+    def attribute
+      :"#{name}_id"
+    end
+
+    # Returns the attribute containing the foreign type (for polymorphic associations)
+    # @example
+    #   Given Bar.belongs_to(:barable, polymorphic: true)
+    #   And self.model == Bar
+    #   Then it returns barable_type
+    # @return [Symbol]
+    def type_key
+      reflection.foreign_type&.to_sym
+    end
+
+    # Returns or defines associated_models
+    # @return [Array<Class>] a class inheriting from ApplicationRecord
+    def associated_models
+      polymorphic? ? polymorphic_associations : regular_associations
+    end
+
+    # Returns true if the reflection is polymorphic
+    # @example
+    #   Given Bar.belongs_to(:barable, polymorphic: true)
+    #   And self.model == Bar
+    #   Then it returns true
+    # @return [Boolean]
+    def polymorphic?
+      reflection.options[:polymorphic]
+    end
+
+    private
+
+    # Returns the reflected models for a regular association
+    # @example
+    #   Given Bar.belongs_to(:foo)
+    #   And Foo.has_many(:bars)
+    #   And self.model == Bar
+    #   Then it returns [Foo]
+    # @return [Array<Class>] a class inheriting from ApplicationRecord
+    def regular_associations
+      [reflection.klass]
+    end
+
+    # Returns the reflected models for a polymorphic association
+    # @example
+    #   Given Bar.belongs_to(:barable, polymorphic: true)
+    #   And Foo.has_many(:bars, as: :barable)
+    #   And Zed.has_many(:bars, as: :barable)
+    #   And #model is Bar
+    #   Then it returns [Foo, Zed]
+    # @return [Array<Class>] a class inheriting from ApplicationRecord
+    def polymorphic_associations
+      DirtySeed::DataModel.active_record_models.select do |active_record_model|
+        active_record_model.reflections.values.any? do |arm_reflection|
+          arm_reflection.options[:as]&.to_sym == name
+        end
+      end
+    end
+  end
+end

data/lib/dirty_seed/dirty_attribute.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module DirtySeed
+  # Represents an Active Record attribute
+  class DirtyAttribute
+    extend ::DirtySeed::MethodMissingHelper
+    forward_missing_methods_to :column
+
+    attr_reader :dirty_model, :column
+
+    # Initializes an instance
+    # @param dirty_model [DirtySeed::DirtyModel]
+    # @param column [ActiveRecord::ConnectionAdapters::Column]
+    # @return [DirtySeed::DirtyAttribute]
+    def initialize(dirty_model, column)
+      @dirty_model = dirty_model
+      @column = column
+    end
+
+    # Assigns a value to the attribute
+    # @param instance [Object] an instance of a class inheriting from ApplicationRecord
+    # @param sequence [Integer]
+    # @return [void]
+    def assign_value(instance, sequence)
+      instance.assign_attributes(name => value(sequence))
+    rescue ArgumentError => e
+      dirty_model.errors << e
+    end
+
+    # Returns a value matching type and validators
+    # @param sequence [Integer]
+    # @return [Object, nil]
+    def value(sequence)
+      assigner = "DirtySeed::Assigners::Dirty#{type.capitalize}".constantize
+      assigner.new(self, sequence).value
+    # If attribute type is not currently handled (json, array...) return nil
+    rescue NameError
+      nil
+    end
+
+    # Returns attribute name
+    # @return [Symbol]
+    def name
+      column.name.to_sym
+    end
+
+    # Returns attribute type
+    # @return [Symbol]
+    def type
+      return :float if column.sql_type_metadata.type == :decimal
+      return :time if column.sql_type_metadata.type == :datetime
+
+      column.sql_type_metadata.type
+    end
+
+    # Returns an validators related to the current attribute
+    # @return [Array<ActiveModel::Validations::EachValidators>]
+    def validators
+      dirty_model.validators.select do |validator|
+        validator.attributes.include? name
+      end
+    end
+  end
+end

data/lib/dirty_seed/dirty_model.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module DirtySeed
+  # Represents an Active Record model
+  class DirtyModel
+    extend ::DirtySeed::MethodMissingHelper
+    forward_missing_methods_to :model
+
+    attr_reader :model, :seeded
+    attr_writer :errors
+
+    PROTECTED_COLUMNS = %w[
+      id
+      type
+      created_at
+      updated_at
+      encrypted_password
+      reset_password_token
+      reset_password_sent_at
+      remember_created_at
+    ].freeze
+    private_constant :PROTECTED_COLUMNS
+
+    # Initializes an instance
+    # @param model [Class] a class inheriting from ApplicationRecord
+    # @return [DirtySeed::DirtyModel]
+    def initialize(model)
+      @model = model
+    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
+      associations.map(&:associated_models).flatten
+    end
+
+    # Returns an dirty associations representing the self.model belongs_to associations
+    # @return [Array<DirtySeed::DirtyAssociation>]
+    def associations
+      included_reflections.map do |reflection|
+        DirtySeed::DirtyAssociation.new(self, reflection)
+      end
+    end
+
+    # Returns model attributes
+    # @return [Array<String>]
+    def attributes
+      included_columns.map do |column|
+        DirtySeed::DirtyAttribute.new(self, column)
+      end
+    end
+
+    # Returns uniq errors
+    # @return [Array<Error>]
+    def errors
+      @errors.flatten.uniq
+    end
+
+    # Creates instances for each model
+    # @param count [Integer]
+    # @return [void]
+    def seed(count = 5)
+      reset_info
+      count.times do |sequence|
+        create_instance(sequence)
+      end
+    end
+
+    private
+
+    # Reset seed info
+    # @return [void]
+    def reset_info
+      @seeded = 0
+      @errors = []
+    end
+
+    # Creates an instance
+    # @param sequence [Integer]
+    # @return [void]
+    def create_instance(sequence)
+      instance = model.new
+      associations.each { |association| association.assign_value(instance) }
+      attributes.each { |attribute| attribute.assign_value(instance, sequence) }
+      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
+      excluded = PROTECTED_COLUMNS + reflection_related_attributes
+      model.columns.reject do |column|
+        column.name.in? excluded
+      end
+    end
+
+    # Returns attributes related to an association
+    # @example
+    #   ["foo_id", "doable_id", "doable_type"]
+    # @return [Array<String>]
+    def reflection_related_attributes
+      all_reflection_related_attributes =
+        associations.map do |association|
+          [association.attribute, association.type_key].compact
+        end
+      all_reflection_related_attributes.flatten.map(&:to_s)
+    end
+
+    # Returns reflections of the model
+    # @return [Array<ActiveRecord::Reflection::BelongsToReflection>]
+    def included_reflections
+      model.reflections.values.select do |reflection|
+        reflection.is_a? ActiveRecord::Reflection::BelongsToReflection
+      end
+    end
+  end
+end

data/lib/dirty_seed/engine.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module DirtySeed
+  class Engine < ::Rails::Engine
+    isolate_namespace DirtySeed
+
+    config.generators do |generators|
+      generators.test_framework :rspec
+    end
+  end
+end

data/lib/dirty_seed/exceptions.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module DirtySeed
+  class Error < StandardError; end
+  class CyclicalAssociationsError < StandardError; end
+end

data/lib/dirty_seed/method_missing_helper.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module DirtySeed
+  # Forwards missing method to another object if it matches
+  module MethodMissingHelper
+    # Defines missing_method and respond_to_missing? methods
+    # @param addressee_key [Object]
+    # @return [Object]
+    # @raise [NoMethodError]
+    def forward_missing_methods_to(addressee_key)
+      define_addressee(addressee_key)
+      define_method_missing
+      define_respond_to_missing?
+    end
+
+    # Defines addressee method
+    # @param addressee_key [Object]
+    # @return [void]
+    def define_addressee(addressee_key)
+      define_method :addressee do
+        public_send(addressee_key)
+      end
+    end
+
+    # 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
+    # @return [void]
+    def define_method_missing
+      define_method :method_missing do |method_name, *args, &block|
+        return super(method_name, *args, &block) unless addressee.respond_to?(method_name)
+
+        addressee.public_send(method_name, *args, &block)
+      end
+    end
+
+    # Defines respond_to_missing? method to matches the method_missing behavior
+    # @return [void]
+    def define_respond_to_missing?
+      define_method :respond_to_missing? do |method_name, _include_private = false|
+        # :nocov:
+        return super(method_name, _include_private = false) unless addressee.respond_to?(method_name)
+
+        true
+        # :nocov:
+      end
+    end
+  end
+end

data/lib/dirty_seed/sorter.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module DirtySeed
+  # Sorts ActiveRecord models depending on their associations
+  class Sorter
+    attr_reader :models, :sorted, :checked, :current, :skip_optional
+    alias unsorted models
+
+    # Initializes an instance
+    # @param models [Array<Class>] models inheriting from ActiveRecord::Base
+    # @return [DirtySeed::Sorter]
+    def initialize(models = [])
+      @models = models
+      @sorted = []
+      @checked = []
+      @current = unsorted.first
+    end
+
+    # Sorts models depending on their associations
+    # @return [Array<Class>] classes inheriting from ActiveRecord::Base
+    def sort!
+      return sorted if unsorted.empty?
+
+      set_current
+      # active skip_optional option to prevent infinite loop
+      skip_optional! if break_loop?
+      insert_or_rotate
+      sort!
+    end
+
+    private
+
+    # Defines the current model to be sorted and add it to the checked ones
+    # @return [Class] class inheriting from ActiveRecord::Base
+    def set_current
+      @current = unsorted.first
+      checked << current
+    end
+
+    # Returns true if the current model has already been checked and skip optional option is not already activated
+    # @return [Boolean]
+    def break_loop?
+      current.in?(checked) && !skip_optional
+    end
+
+    # Activates skip_optional option to prevent infinite loop
+    # @return [void]
+    def skip_optional!
+      # if skip_optional is already true
+      # there is an infinite loop of belongs_to associations
+      raise DirtySeed::CyclicalAssociationsError if skip_optional
+
+      @skip_optional = true
+      @checked = []
+    end
+
+    # Chooses if current should be added to sorted ones or not
+    # @return [void]
+    def insert_or_rotate
+      # if the current is dependent form a non-sorted model
+      if dependent?
+        # rotate models array so current will be sorted at the end
+        unsorted.rotate!
+      else
+        # removed current from unsorted and add it to sorted
+        sorted << unsorted.shift
+      end
+    end
+
+    # Returns true if @current belongs_to a model that has not been sorted yet
+    # @return [Boolean]
+    def dependent?
+      return false if unsorted.one?
+
+      current.reflections.values.any? do |reflection|
+        belongs_to?(reflection) &&
+          unsorted.any? do |model|
+            mirror?(model, reflection)
+          end
+      end
+    end
+
+    # Returns true if relfection is a :belongs_to kind
+    # @param reflection [ActiveRecord::Reflection::AssociationReflection]
+    # @return [Boolean]
+    def belongs_to?(reflection)
+      return false if reflection.options[:optional] && skip_optional
+
+      reflection.is_a?(ActiveRecord::Reflection::BelongsToReflection)
+    end
+
+    # Returns true if model is or can be the <reflection> mirror
+    # @param model [ActiveRecord model]
+    # @param reflection [ActiveRecord::Reflection::AssociationReflection]
+    # @example
+    #   Given `Foo.belongs_to(:bar)`
+    #   And `Bar.has_many(:foos)`
+    #   And <reflection> is the belongs_to reflection
+    #   Then mirror?(Bar, reflection) returns true
+    # @example
+    #   Given `Foo.belongs_to(:foable, polymorphic: true)`
+    #   And `Bar.has_many(:foos, as: :foable)`
+    #   And `Baz.has_many(:foos, as: :foable)`
+    #   And <reflection> is the Foo "belongs_to" reflection
+    #   Then mirror?(Bar, reflection) returns true
+    #   And mirror?(Baz, reflection) returns true
+    # @return [Boolean]
+    def mirror?(model, reflection)
+      if reflection.options[:polymorphic]
+        model.reflections.values.any? do |model_reflection|
+          model_reflection.options[:as] == reflection.name
+        end
+      else
+        model == reflection.klass
+      end
+    end
+  end
+end