seedie 0.2.0 → 0.4.0

data/lib/seedie/field_values/value_template_validator.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module Seedie
+  module FieldValues
+    class ValueTemplateValidator
+      VALID_KEYS = %w[values value options].freeze
+      PICK_STRATEGIES = %w[random sequential].freeze
+
+      def initialize(value_template, index, name)
+        @value_template = value_template
+        @index = index
+        @name = name
+      end
+
+      def validate
+        return unless @value_template.is_a?(Hash)
+
+        validate_keys
+        validate_values if @value_template.key?("values")
+        validate_options if @value_template.key?("options")
+      end
+
+      private
+
+      def validate_keys
+        invalid_keys = @value_template.keys - VALID_KEYS
+
+        if invalid_keys.present?
+          raise InvalidCustomFieldKeysError,
+                "Invalid keys for #{@name}: #{invalid_keys.join(', ')}. Only #{VALID_KEYS} are allowed."
+        end
+
+        return unless @value_template.key?("values")
+
+        if @value_template.key?("value")
+          raise InvalidCustomFieldKeysError,
+                "Invalid keys for #{@name}: values and value cannot be used together."
+        end
+
+        return unless @value_template["values"].is_a?(Hash)
+
+        return unless !@value_template["values"].key?("start") || !@value_template["values"].key?("end")
+
+        raise InvalidCustomFieldValuesError,
+              "The values key for #{@name} must be an array or a hash with start and end keys."
+      end
+
+      def validate_values
+        values = @value_template["values"]
+
+        unless values.is_a?(Array) || values.is_a?(Hash)
+          raise InvalidCustomFieldValuesError,
+                "The values key for #{@name} must be an array or a hash with start and end keys."
+        end
+
+        validate_sequential_values_length
+      end
+
+      def validate_options
+        options = @value_template["options"]
+        pick_strategy = options["pick_strategy"]
+
+        return unless pick_strategy.present? && !PICK_STRATEGIES.include?(pick_strategy)
+
+        raise InvalidCustomFieldOptionsError,
+              "The pick_strategy for #{@name} must be either 'sequential' or 'random'."
+      end
+
+      ## If pick strategy is sequential, we need to ensure there is a value for each index
+      # If there isn't sufficient values, we raise an error
+      def validate_sequential_values_length
+        return unless @value_template.key?("options")
+        return unless @value_template["options"]["pick_strategy"] == "sequential"
+
+        values = @value_template["values"]
+
+        values_length = if values.is_a?(Hash) && values.keys.sort == %w[end start]
+                          # Assuming the values are an inclusive range
+                          values["end"] - values["start"] + 1
+                        else
+                          values.length
+                        end
+
+        return unless values_length < @index + 1
+
+        raise CustomFieldNotEnoughValuesError,
+              "There are not enough values for #{@name}. Please add more values."
+      end
+    end
+  end
+end

data/lib/seedie/field_values_set.rb

@@ -1,6 +1,8 @@
+# frozen_string_literal: true
+
 module Seedie
   class FieldValuesSet
-    attr_reader :attributes_config, :index
+    attr_reader :model, :model_config, :attributes_config, :index
 
     def initialize(model, model_config, index)
       @model = model
@@ -18,6 +20,12 @@ module Seedie
       @field_values
     end
 
+    def generate_field_values_with_associations
+      associated_field_values_set = generate_belongs_to_associations
+      model_field_values_set = generate_field_values
+      model_field_values_set.merge!(associated_field_values_set)
+    end
+
     def generate_field_value(name, column)
       return generate_custom_field_value(name) if @attributes_config&.key?(name)
 
@@ -26,18 +34,27 @@ module Seedie
 
     private
 
+    def generate_belongs_to_associations
+      associations_config = model_config["associations"]
+      return {} unless associations_config.present?
+
+      belongs_to_associations = Associations::BelongsTo.new(model, associations_config)
+      belongs_to_associations.generate_associations
+      belongs_to_associations.associated_field_set
+    end
+
     def populate_values_for_model_fields
       @field_values = @model.columns_hash.map do |name, column|
         next if @model_fields.disabled_fields.include?(name)
         next if @model_fields.foreign_fields.include?(name)
-        
+
         [name, generate_field_value(name, column)]
       end.compact.to_h
     end
 
     def populate_values_for_virtual_fields
       virtual_fields = @attributes_config.keys - @model.columns_hash.keys
-      
+
       virtual_fields.each do |name|
         @field_values[name] = generate_custom_field_value(name) if @attributes_config[name]
       end
@@ -47,4 +64,4 @@ module Seedie
       FieldValues::CustomValue.new(name, @attributes_config[name], @index).generate_custom_field_value
     end
   end
-end
+end

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,9 +21,8 @@ module Seedie
 
         @resolved_queue
       end
-    
-      private
 
+      private
 
       # Independent models need to be added first
       def add_independent_models_to_queue
@@ -31,7 +32,7 @@ module Seedie
           end
         end
       end
-    
+
       def resolve_dependencies(model)
         if @unresolved.include?(model)
           puts "Circular dependency detected for #{model}. Ignoring..."
@@ -39,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)
@@ -65,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
@@ -74,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}"
@@ -90,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