seedie 0.3.0 → 0.4.1

data/lib/seedie/model/creator.rb

@@ -1,18 +1,20 @@
+# frozen_string_literal: true
+
 module Seedie
   module Model
     class Creator
       include Reporters::Reportable
-      
+
       def initialize(model, reporters = [])
         @model = model
         @reporters = reporters
 
         add_observers(@reporters)
       end
-      
+
       def create!(field_values_set)
         record = @model.create!(field_values_set)
-        report(:record_created, name: "#{record.class}", id: "#{record.id}")
+        report(:record_created, name: record.class.to_s, id: record.id.to_s)
 
         record
       end
@@ -22,9 +24,9 @@ module Seedie
           create!(field_values_set)
         rescue ActiveRecord::RecordInvalid => e
           report(:record_invalid, record: e.record)
-          return nil
+          nil
         end
       end
     end
   end
-end
+end

data/lib/seedie/model/id_generator.rb

@@ -1,30 +1,32 @@
+# frozen_string_literal: true
+
 module Seedie
   module Model
     class IdGenerator
       def initialize(model)
         @model = model
       end
-  
+
       def random_id
         id = @model.pluck(:id).sample
         raise InvalidAssociationConfigError, "#{@model} has no records" unless id
 
-        return id
+        id
       end
-      
+
       def unique_id_for(association_klass, model_id_column)
         unless association_klass.column_names.include?(model_id_column)
-          raise InvalidAssociationConfigError, "#{model_id_column} does not exist in #{association_klass}" 
+          raise InvalidAssociationConfigError, "#{model_id_column} does not exist in #{association_klass}"
         end
-      
+
         unique_ids = @model.ids - association_klass.pluck(model_id_column)
-      
+
         if unique_ids.empty?
           raise InvalidAssociationConfigError, "No unique ids for #{@model}"
         end
-      
+
         unique_ids.first
       end
     end
   end
-end
+end

data/lib/seedie/model/model_sorter.rb

@@ -1,15 +1,17 @@
+# frozen_string_literal: true
+
 module Seedie
   module Model
     class ModelSorter
       include PolymorphicAssociationHelper
-      
+
       def initialize(models)
         @models = models
-        @model_dependencies = models.map {|m| [m, get_model_dependencies(m)]}.to_h
+        @model_dependencies = models.map { |m| [m, get_model_dependencies(m)] }.to_h
         @resolved_queue = []
         @unresolved = []
       end
-    
+
       def sort_by_dependency
         add_independent_models_to_queue
 
@@ -19,7 +21,7 @@ module Seedie
 
         @resolved_queue
       end
-    
+
       private
 
       # Independent models need to be added first
@@ -30,7 +32,7 @@ module Seedie
           end
         end
       end
-    
+
       def resolve_dependencies(model)
         if @unresolved.include?(model)
           puts "Circular dependency detected for #{model}. Ignoring..."
@@ -38,25 +40,21 @@ module Seedie
         end
 
         @unresolved << model
-        dependencies = @model_dependencies[model]
-        
-        if dependencies
-          dependencies.each do |dependency|
-            resolve_dependencies(dependency) unless @resolved_queue.include?(dependency)
-          end
+        @model_dependencies[model]&.each do |dependency|
+          resolve_dependencies(dependency) unless @resolved_queue.include?(dependency)
         end
 
         @resolved_queue << model
         @unresolved.delete(model)
       end
-    
+
       def get_model_dependencies(model)
         associations = model.reflect_on_all_associations(:belongs_to).reject do |association|
           association.options[:optional] == true # Excluded Optional Associations
         end
-      
+
         return [] if associations.blank?
-      
+
         associations.map do |association|
           if association.options[:class_name]
             constantize_class_name(association.options[:class_name], model.name)
@@ -64,7 +62,7 @@ module Seedie
             types = find_polymorphic_types(model, association.name)
 
             if types.blank?
-              puts "Polymorphic type not found for #{model.name}. Ignoring..." 
+              puts "Polymorphic type not found for #{model.name}. Ignoring..."
               next
             end
           else
@@ -73,8 +71,6 @@ module Seedie
         end.compact
       end
 
-      private
-
       def constantize_class_name(class_name, model_name)
         namespaced_class_name = if model_name.include?("::")
                                   "#{model_name.deconstantize}::#{class_name}"
@@ -89,6 +85,6 @@ module Seedie
           class_name.constantize
         end
       end
-    end    
+    end
   end
 end

data/lib/seedie/model_fields.rb

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 module Seedie
   class ModelFields
-    DEFAULT_DISABLED_FIELDS = %w[id created_at updated_at]
+    DEFAULT_DISABLED_FIELDS = %w[id created_at updated_at].freeze
 
     attr_reader :model_name, :model_config, :fields, :disabled_fields, :foreign_fields
-    
+
     def initialize(model, model_config)
       @model_name = model.to_s
       @model_config = model_config
@@ -13,4 +15,4 @@ module Seedie
       @other_fields = model.column_names - @disabled_fields - @custom_fields - @foreign_fields
     end
   end
-end
+end

data/lib/seedie/model_seeder.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Seedie
   class ModelSeeder
     include Reporters::Reportable
@@ -12,22 +14,22 @@ module Seedie
       @config = config
       @record_creator = Model::Creator.new(model, reporters)
       @reporters = reporters
-
       add_observers(@reporters)
     end
 
     def generate_records
-      report(:model_seed_start, name: "#{model.to_s}")
+      report(:model_seed_start, name: model.to_s)
       model_count(model_config).times do |index|
         record = generate_record(model_config, index)
         associations_config = model_config["associations"]
 
-        if associations_config.present?
-          Associations::HasMany.new(record, model, associations_config, reporters).generate_associations
-          Associations::HasOne.new(record, model, associations_config, reporters).generate_associations
-        end
+        next unless associations_config.present?
+
+        Associations::HasMany.new(record, model, associations_config, reporters).generate_associations
+        Associations::HasAndBelongsToMany.new(record, model, associations_config, reporters).generate_associations
+        Associations::HasOne.new(record, model, associations_config, reporters).generate_associations
       end
-      report(:model_seed_finish, name: "#{model.to_s}")
+      report(:model_seed_finish, name: model.to_s)
     end
 
     private
@@ -40,21 +42,8 @@ module Seedie
     end
 
     def generate_record(model_config, index)
-      associated_field_set = generate_belongs_to_associations(model, model_config)
-
-      field_values_set = FieldValuesSet.new(model, model_config, index).generate_field_values
-      field_values_set.merge!(associated_field_set)
+      field_values_set = FieldValuesSet.new(model, model_config, index).generate_field_values_with_associations
       @record_creator.create!(field_values_set)
     end
-
-    def generate_belongs_to_associations(model, model_config)
-      associations_config = model_config["associations"]
-      return {} unless associations_config.present?
-
-      belongs_to_associations = Associations::BelongsTo.new(model, associations_config, reporters)
-      belongs_to_associations.generate_associations
-      
-      return belongs_to_associations.associated_field_set
-    end
   end
-end
+end

data/lib/seedie/polymorphic_association_helper.rb

@@ -1,20 +1,24 @@
-module PolymorphicAssociationHelper
-  # Returns the type of the polymorphic association
-  # We need only one polymorphic association while generating config
-  # this makes it easier to sort according to dependencies
-  def find_polymorphic_types(model, association_name)
-    type = @models.find { |potential_model| has_association?(potential_model, association_name) }
-    type&.name&.underscore
-  end
+# frozen_string_literal: true
 
-  def has_association?(model, association_name)
-    associations = select_associations(model)
-    associations.any? { |association| association.options[:as] == association_name }
-  end
-  
-  def select_associations(model)
-    model.reflect_on_all_associations.select do |reflection|
-      %i[has_many has_one].include?(reflection.macro)
+module Seedie
+  module PolymorphicAssociationHelper
+    # Returns the type of the polymorphic association
+    # We need only one polymorphic association while generating config
+    # this makes it easier to sort according to dependencies
+    def find_polymorphic_types(_model, association_name)
+      type = @models.find { |potential_model| has_association?(potential_model, association_name) }
+      type&.name&.underscore
+    end
+
+    def has_association?(model, association_name)
+      associations = select_associations(model)
+      associations.any? { |association| association.options[:as] == association_name }
+    end
+
+    def select_associations(model)
+      model.reflect_on_all_associations.select do |reflection|
+        %i[has_many has_one].include?(reflection.macro)
+      end
     end
   end
 end

data/lib/seedie/railtie.rb

@@ -1,5 +1,6 @@
+# frozen_string_literal: true
+
 require "seedie"
-require "rails"
 
 module Seedie
   class Railtie < Rails::Railtie
@@ -7,4 +8,4 @@ module Seedie
       load "tasks/seedie.rake"
     end
   end
-end
+end

data/lib/seedie/reporters/base_reporter.rb

@@ -1,81 +1,88 @@
-module Reporters
-  class BaseReporter
-    INDENT_SIZE = 2
+# frozen_string_literal: true
 
-    attr_reader :output, :reports
+module Seedie
+  module Reporters
+    class BaseReporter
+      INDENT_SIZE = 2
 
-    def initialize(output = nil)
-      @output = output || StringIO.new
-      @reports = []
-      @indent_level = 0
-    end
+      attr_reader :output, :reports
 
-    def update(event_type, options)
-      raise NotImplementedError, "Subclasses must define 'update'."
-    end
+      def initialize(output = nil)
+        @output = output || StringIO.new
+        @reports = []
+        @indent_level = 0
+      end
 
-    def close
-      return if output.closed?
-      output.flush
-    end
+      def update(event_type, options)
+        raise NotImplementedError, "Subclasses must define 'update'."
+      end
 
-    private
+      def close
+        return if output.closed?
 
-    def messages(event_type, options)
-      case event_type
-      when :seed_start
-        "############ SEEDIE RUNNING #############"
-      when :seed_finish
-        "############ SEEDIE FINISHED ############"
-      when :model_seed_start
-        "Seeding #{options[:name]}"
-      when :model_seed_finish
-        "Seeding #{options[:name]} finished!"
-      when :record_created
-        "Created #{options[:name]} with id: #{options[:id]}"
-      when :has_many_start
-        "Creating HasMany associations:"
-      when :belongs_to_start
-        "Creating BelongsTo associations:"
-      when :has_one_start
-        "Creating HasOne associations:"
-      when :associated_records
-        "Creating #{options[:count]} #{options[:name]} for #{options[:parent_name]}"
-      when :random_association
-        "Randomly associating #{options[:name]} with id: #{options[:id]} for #{options[:parent_name]}"
-      when :unique_association
-        "Uniquely associating #{options[:name]} for #{options[:parent_name]}"
-      when :belongs_to_associations
-        "Creating a new #{options[:name].titleize} for #{options[:parent_name]}"
-      else
-        "Unknown event type"
+        output.flush
       end
-    end
 
-    def indent_level_for(event_type)
-      indent_levels = {
-        seed_start: 0, 
-        seed_finish: 0, 
-        model_seed_start: 1, 
-        model_seed_finish: 1, 
-        record_created: 1, 
-        random_association: 1,
-        has_many_start: 2, 
-        belongs_to_start: 2, 
-        has_one_start: 2, 
-        associated_records: 3, 
-        belongs_to_associations: 3
-      }
+      private
 
-      indent_levels[event_type]
-    end
+      def messages(event_type, options)
+        case event_type
+        when :seed_start
+          "############ SEEDIE RUNNING #############"
+        when :seed_finish
+          "############ SEEDIE FINISHED ############"
+        when :model_seed_start
+          "Seeding #{options[:name]}"
+        when :model_seed_finish
+          "Seeding #{options[:name]} finished!"
+        when :record_created
+          "Created #{options[:name]} with id: #{options[:id]}"
+        when :has_many_start
+          "Creating HasMany associations:"
+        when :belongs_to_start
+          "Creating BelongsTo associations:"
+        when :has_one_start
+          "Creating HasOne associations:"
+        when :has_and_belongs_to_many_start
+          "Creating HasAndBelongsToMany associations:"
+        when :associated_records
+          "Creating #{options[:count]} #{options[:name]} for #{options[:parent_name]}"
+        when :random_association
+          "Randomly associating #{options[:name]} with id: #{options[:id]} for #{options[:parent_name]}"
+        when :unique_association
+          "Uniquely associating #{options[:name]} for #{options[:parent_name]}"
+        when :belongs_to_associations
+          "Creating a new #{options[:name].titleize} for #{options[:parent_name]}"
+        else
+          "Unknown event type"
+        end
+      end
+
+      def indent_level_for(event_type)
+        indent_levels = {
+          seed_start: 0,
+          seed_finish: 0,
+          model_seed_start: 1,
+          model_seed_finish: 1,
+          record_created: 1,
+          random_association: 1,
+          has_many_start: 2,
+          belongs_to_start: 2,
+          has_one_start: 2,
+          associated_records: 3,
+          belongs_to_associations: 3
+        }
+
+        indent_levels[event_type]
+      end
 
-    def set_indent_level(event_type)
-      if event_type.in?([:record_created, :random_association, :unique_association])
-        @indent_level += 1 if !@reports.last[:event_type].in?([:record_created, :random_association, :unique_association])
-      elsif @reports.blank? || @reports.last[:event_type] != event_type
-        @indent_level = indent_level_for(event_type)
+      def update_indent_level(event_type)
+        if event_type.in?(%i[record_created random_association unique_association])
+          @indent_level += 1 if !@reports.last[:event_type].in?(%i[record_created random_association unique_association])
+        elsif @reports.blank? || @reports.last[:event_type] != event_type
+          @indent_level = indent_level_for(event_type)
+        end
       end
     end
   end
-end
+end

data/lib/seedie/reporters/console_reporter.rb

@@ -1,16 +1,20 @@
-module Reporters
-  class ConsoleReporter < BaseReporter
-    def initialize
-      super($stdout)
-    end
+# frozen_string_literal: true
+
+module Seedie
+  module Reporters
+    class ConsoleReporter < BaseReporter
+      def initialize
+        super($stdout)
+      end
 
-    def update(event_type, options)
-      indent_level = set_indent_level(event_type)
-      message = messages(event_type, options)
-      @reports << { event_type: event_type, message: message }
+      def update(event_type, options)
+        update_indent_level(event_type)
+        message = messages(event_type, options)
+        @reports << { event_type: event_type, message: message }
 
-      output.print "#{" " * INDENT_SIZE * @indent_level}"
-      output.puts message
+        output.print "#{' ' * INDENT_SIZE * @indent_level}"
+        output.puts message
+      end
     end
   end
-end
+end

data/lib/seedie/reporters/reportable.rb

@@ -1,16 +1,20 @@
+# frozen_string_literal: true
+
 require "observer"
 
-module Reporters
-  module Reportable
-    include Observable
+module Seedie
+  module Reporters
+    module Reportable
+      include Observable
 
-    def report(event_type, options = {})
-      changed
-      notify_observers(event_type, options)
-    end
+      def report(event_type, options = {})
+        changed
+        notify_observers(event_type, options)
+      end
 
-    def add_observers(observers)
-      observers.each { |observer| add_observer(observer) }
+      def add_observers(observers)
+        observers.each { |observer| add_observer(observer) }
+      end
     end
   end
-end
+end

data/lib/seedie/seeder.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Seedie
   class Seeder
     include Reporters::Reportable
@@ -23,7 +25,7 @@ module Seedie
         end
       end
       report(:seed_finish)
-      
+
       @reporters.each(&:close)
     end
 
@@ -32,8 +34,8 @@ module Seedie
     def load_config(path)
       path = Rails.root.join("config", "seedie.yml") if path.nil?
       raise ConfigFileNotFound, "Config file not found in #{path}" unless File.exist?(path)
-      
+
       YAML.load_file(path)
     end
   end
-end
+end

data/lib/seedie/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Seedie
-  VERSION = "0.3.0"
+  VERSION = "0.4.1"
 end

data/lib/seedie.rb

@@ -1,38 +1,15 @@
 # frozen_string_literal: true
 
-require_relative "seedie/reporters/reportable"
-require_relative "seedie/reporters/base_reporter"
-require_relative "seedie/reporters/console_reporter"
-
-require_relative "seedie/field_values/fake_value"
-require_relative "seedie/field_values/custom_value"
-require_relative "seedie/field_values/faker_builder"
-require_relative "seedie/field_values_set"
-require_relative "seedie/model_fields"
-require_relative "seedie/model_seeder"
-
-require_relative "seedie/polymorphic_association_helper"
-
-require_relative "seedie/model/creator"
-require_relative "seedie/model/model_sorter"
-require_relative "seedie/model/id_generator"
-
-require_relative "seedie/associations/base_association"
-require_relative "seedie/associations/has_many"
-require_relative "seedie/associations/has_one"
-require_relative "seedie/associations/belongs_to"
-
-require_relative "seedie/seeder"
-require_relative "seedie/version"
-require_relative "seedie/configuration"
-
-require "seedie/railtie" if defined?(Rails)
-
 require "active_record"
 require "faker"
 require "yaml"
+require "zeitwerk"
 
 module Seedie
+  @loader = Zeitwerk::Loader.for_gem
+  @loader.ignore("#{__dir__}/generators")
+  @loader.setup
+
   class Error < StandardError; end
   class InvalidFakerMethodError < StandardError; end
   class UnknownColumnTypeError < StandardError; end
@@ -51,5 +28,11 @@ module Seedie
     def configuration
       @configuration ||= Configuration.new
     end
+
+    def eager_load!
+      @loader.eager_load
+    end
   end
 end
+
+Seedie.eager_load!

data/lib/tasks/seedie.rake

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 require "seedie"
 
 namespace :seedie do
   desc "Load the Seedie seeds"
-  task :seed => :environment do
+  task seed: :environment do
     Seedie::Seeder.new.seed_models
   end
-end
+end