seedie 0.1.0

data/lib/seedie/field_values/fake_value.rb

@@ -0,0 +1,49 @@
+module Seedie
+  module FieldValues
+    class FakeValue
+      def initialize(name, column)
+        @name = name
+        @column = column
+      end
+
+      def generate_fake_value
+        case @column.type
+        when :string, :text, :citext
+          Faker::Lorem.word
+        when :uuid
+          SecureRandom.uuid
+        when :integer, :bigint, :smallint
+          Faker::Number.number(digits: 5)
+        when :decimal, :float, :real
+          Faker::Number.decimal(l_digits: 2, r_digits: 2)
+        when :datetime, :timestamp, :timestamptz
+          Faker::Time.between(from: DateTime.now - 1, to: DateTime.now)
+        when :date
+          Faker::Date.between(from: Date.today - 2, to: Date.today)
+        when :time, :timetz
+          Faker::Time.forward(days: 23, period: :morning)
+        when :boolean
+          Faker::Boolean.boolean
+        when :json, :jsonb
+          { "key1" => Faker::Lorem.word, "key2" => Faker::Number.number(digits: 2) }
+        when :inet
+          Faker::Internet.ip_v4_address
+        when :cidr, :macaddr
+          Faker::Internet.mac_address
+        when :bytea
+          Faker::Internet.password
+        when :bit, :bit_varying
+          ["0","1"].sample
+        when :money
+          Faker::Commerce.price.to_s
+        when :hstore
+          { "key1" => Faker::Lorem.word, "key2" => Faker::Number.number(digits: 2) }
+        when :year
+          rand(1901..2155)
+        else
+          raise UnknownColumnTypeError, "Unknown column type: #{@column.type}"
+        end
+      end
+    end
+  end
+end

data/lib/seedie/field_values/faker_builder.rb

@@ -0,0 +1,138 @@
+module Seedie
+  module FieldValues
+    class FakerBuilder
+      def initialize(name, column, validations)
+        @name = name
+        @column = column
+        @validations = validations
+        @faker_expression = "{{Faker::"
+        @unique_prefix = ""
+        @class_prefix = ""
+        @method_prefix = ""
+        @options = ""
+      end
+
+      def build_faker_constant
+        @unique_prefix = "unique." if has_validation?(:uniqueness)
+        
+        add_faker_class_and_method(@column.type)
+        
+        if has_validation?(:inclusion)
+          handle_inclusion_validation 
+        else
+          @options += handle_numericality_validation if has_validation?(:numericality)
+          @options += handle_length_validation if has_validation?(:length)
+        end
+
+        if @faker_expression.is_a?(String)
+          @faker_expression += "#{@class_prefix}#{@unique_prefix}#{@method_prefix}#{@options}"
+          @faker_expression += "}}" if @faker_expression.start_with?("{{") # We may not need }} when random attributes
+        end
+
+        @faker_expression
+      end
+
+      private
+
+      def add_faker_class_and_method(type)
+        case type
+        when :string, :text, :citext
+          @class_prefix = "Lorem."
+          @method_prefix = "word"
+        when :uuid
+          @class_prefix = "Internet."
+          @method_prefix = "uuid"
+        when :integer, :bigint, :smallint
+          @class_prefix = "Number."
+          @method_prefix = "number"
+          @options = "(digits: 5)"
+        when :decimal, :float, :real
+          @class_prefix = "Number."
+          @method_prefix = "decimal"
+          @options = "(l_digits: 2, r_digits: 2)"
+        when :datetime, :timestamp, :timestamptz, :time, :timetz
+          @class_prefix = "Time."
+          @method_prefix = "between"
+          @options = "(from: DateTime.now - 1, to: DateTime.now)"
+        when :date
+          @class_prefix = "Date."
+          @method_prefix = "between"
+          @options = "(from: Date.today - 1, to: Date.today)"
+        when :boolean
+          @class_prefix = "Boolean."
+          @method_prefix = "boolean"
+        when :json, :jsonb
+          @class_prefix = "Json."
+          @method_prefix = "shallow_json(width: 3, options: { key: \"Name.first_name\", value: \"Number.number(digits: 2)\" })"
+        when :inet
+          @class_prefix = "Internet."
+          @method_prefix = "ip_v4_address"
+        when :cidr, :macaddr
+          @class_prefix = "Internet."
+          @method_prefix = "mac_address"
+        when :bytea
+          @class_prefix = "Internet."
+          @method_prefix = "password"
+        when :bit, :bit_varying
+          @class_prefix = "Internet."
+          @method_prefix = "password"
+        when :money
+          @class_prefix = "Commerce."
+          @method_prefix = "price.to_s"
+        when :hstore
+          @class_prefix = "Json."
+          @method_prefix = "shallow_json"
+          @options = "(width: 3, options: { key: \"Name.first_name\", value: \"Number.number(digits: 2)\" })"
+        when :year
+          @class_prefix = "Number."
+          @method_prefix = "number"
+          @options = "(digits: 4)"
+        else
+          raise UnknownColumnTypeError, "Unknown column type: #{type}"
+        end
+      end
+
+      def has_validation?(kind)
+        @validations.any? { |validation| validation.kind == kind }
+      end
+
+      def handle_numericality_validation
+        numericality_validator = @validations.find { |v| v.kind == :numericality }
+        options = numericality_validator.options
+        if options[:greater_than_or_equal_to] && options[:less_than_or_equal_to]
+          ".between(from: #{options[:greater_than_or_equal_to]}, to: #{options[:less_than_or_equal_to]})"
+        elsif options[:greater_than_or_equal_to]
+          ".between(from: #{options[:greater_than_or_equal_to]})"
+        elsif options[:less_than_or_equal_to]
+          ".between(to: #{options[:less_than_or_equal_to]})"
+        else
+          ""
+        end
+      end
+
+      def handle_length_validation
+        length_validator = @validations.find { |v| v.kind == :length }
+        @method_prefix = "characters"
+        options = length_validator.options
+        if options[:minimum] && options[:maximum]
+          "(number: rand(#{options[:minimum]}..#{options[:maximum]}))"
+        elsif options[:minimum]
+          "(number: rand(#{options[:minimum]}..100))"
+        elsif options[:maximum]
+          "(number: rand(1..#{options[:maximum]}))"
+        else
+          ""
+        end
+      end
+
+      def handle_inclusion_validation
+        inclusion_validator = @validations.find { |v| v.kind == :inclusion }
+        options = inclusion_validator.options
+        @class_prefix = ""
+        @method_prefix = ""
+        @options = ""
+        @faker_expression = { "custom_attr_value" => { "values" => options[:in], "pick_strategy" => "random" } }
+      end
+    end
+  end
+end

data/lib/seedie/field_values_set.rb

@@ -0,0 +1,50 @@
+module Seedie
+  class FieldValuesSet
+    attr_reader :attributes_config, :index
+
+    def initialize(model, model_config, index)
+      @model = model
+      @model_config = model_config
+      @index = index
+      @attributes_config = model_config["attributes"]
+      @model_fields = ModelFields.new(model, model_config)
+      @field_values = {}
+    end
+
+    def generate_field_values
+      populate_values_for_model_fields
+      populate_values_for_virtual_fields if @attributes_config
+
+      @field_values
+    end
+
+    def generate_field_value(name, column)
+      return generate_custom_field_value(name) if @attributes_config&.key?(name)
+
+      FieldValues::FakeValue.new(name, column).generate_fake_value
+    end
+
+    private
+
+    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
+    end
+
+    def generate_custom_field_value(name)
+      FieldValues::CustomValue.new(name, @attributes_config[name], @index).generate_custom_field_value
+    end
+  end
+end

data/lib/seedie/model/creator.rb

@@ -0,0 +1,30 @@
+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}")
+
+        record
+      end
+
+      def create(field_values_set)
+        begin
+          create!(field_values_set)
+        rescue ActiveRecord::RecordInvalid => e
+          report(:record_invalid, record: e.record)
+          return nil
+        end
+      end
+    end
+  end
+end

data/lib/seedie/model/id_generator.rb

@@ -0,0 +1,32 @@
+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
+      end
+      
+      def unique_id_for(association_klass)
+        model_id_column = "#{@model.to_s.underscore}_id"
+      
+        unless association_klass.column_names.include?(model_id_column)
+          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

data/lib/seedie/model/model_sorter.rb

@@ -0,0 +1,87 @@
+module Seedie
+  module Model
+    class ModelSorter
+      def initialize(models)
+        @models = models
+        @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
+
+        @models.each do |model|
+          resolve_dependencies(model) unless @resolved_queue.include?(model)
+        end
+
+        @resolved_queue
+      end
+    
+      private
+
+
+      # Independent models need to be added first
+      def add_independent_models_to_queue
+        @models.each do |model|
+          if @model_dependencies[model].empty?
+            @resolved_queue << model
+          end
+        end
+      end
+    
+      def resolve_dependencies(model)
+        if @unresolved.include?(model)
+          puts "Circular dependency detected for #{model}. Ignoring..."
+          return
+        end
+
+        @unresolved << model
+        dependencies = @model_dependencies[model]
+        
+        if dependencies
+          dependencies.each do |dependency|
+            resolve_dependencies(dependency) unless @resolved_queue.include?(dependency)
+          end
+        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[:polymorphic] == true || # Excluded Polymorphic Associations
+          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)
+          else
+            association.klass
+          end
+        end
+      end
+
+      private
+
+      def constantize_class_name(class_name, model_name)
+        namespaced_class_name = if model_name.include?("::")
+                                  "#{model_name.deconstantize}::#{class_name}"
+                                else
+                                  class_name
+                                end
+        begin
+          namespaced_class_name.constantize
+        rescue NameError
+          # If the class_name with the namespace doesn't exist, try without the namespace
+          puts "Class #{namespaced_class_name} not found. Trying without the namespace... #{class_name}"
+          class_name.constantize
+        end
+      end
+    end    
+  end
+end

data/lib/seedie/model_fields.rb

@@ -0,0 +1,16 @@
+module Seedie
+  class ModelFields
+    DEFAULT_DISABLED_FIELDS = %w[id created_at updated_at]
+
+    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
+      @custom_fields = model_config["attributes"]&.keys || []
+      @disabled_fields = [(model_config["disabled_fields"] || []) + DEFAULT_DISABLED_FIELDS].flatten.uniq
+      @foreign_fields = model.reflect_on_all_associations(:belongs_to).map(&:foreign_key)
+      @other_fields = model.column_names - @disabled_fields - @custom_fields - @foreign_fields
+    end
+  end
+end

data/lib/seedie/model_seeder.rb

@@ -0,0 +1,60 @@
+module Seedie
+  class ModelSeeder
+    include Reporters::Reportable
+
+    DEFAULT_MODEL_COUNT = 1
+
+    attr_reader :model, :model_config, :config, :reporters
+
+    def initialize(model, model_config, config, reporters)
+      @model = model
+      @model_config = model_config
+      @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}")
+      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
+      end
+      report(:model_seed_finish, name: "#{model.to_s}")
+    end
+
+    private
+
+    def model_count(model_config)
+      return model_config["count"] if model_config["count"].present?
+      return config["default_count"] if config["default_count"].present?
+
+      DEFAULT_MODEL_COUNT
+    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)
+      @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

data/lib/seedie/railtie.rb

@@ -0,0 +1,10 @@
+require "seedie"
+require "rails"
+
+module Seedie
+  class Railtie < Rails::Railtie
+    rake_tasks do
+      load "tasks/seedie.rake"
+    end
+  end
+end

data/lib/seedie/reporters/base_reporter.rb

@@ -0,0 +1,81 @@
+module Reporters
+  class BaseReporter
+    INDENT_SIZE = 2
+
+    attr_reader :output, :reports
+
+    def initialize(output = nil)
+      @output = output || StringIO.new
+      @reports = []
+      @indent_level = 0
+    end
+
+    def update(event_type, options)
+      raise NotImplementedError, "Subclasses must define 'update'."
+    end
+
+    def close
+      return if output.closed?
+      output.flush
+    end
+
+    private
+
+    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"
+      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)
+      end
+    end
+  end
+end

data/lib/seedie/reporters/console_reporter.rb

@@ -0,0 +1,16 @@
+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 }
+
+      output.print "#{" " * INDENT_SIZE * @indent_level}"
+      output.puts message
+    end
+  end
+end

data/lib/seedie/reporters/reportable.rb

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

data/lib/seedie/seeder.rb

@@ -0,0 +1,39 @@
+module Seedie
+  class Seeder
+    include Reporters::Reportable
+
+    attr_reader :config
+
+    def initialize(config_path = nil)
+      @config_path = config_path
+      @config = load_config(config_path)
+      @reporters = []
+      @console_reporter = Reporters::ConsoleReporter.new
+      @reporters << @console_reporter
+
+      add_observers(@reporters)
+    end
+
+    def seed_models
+      report(:seed_start)
+      ActiveRecord::Base.transaction do
+        config["models"].each do |model_name, model_config|
+          model = model_name.classify.constantize
+          ModelSeeder.new(model, model_config, config, @reporters).generate_records
+        end
+      end
+      report(:seed_finish)
+      
+      @reporters.each(&:close)
+    end
+
+    private
+
+    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

data/lib/seedie/version.rb

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

data/lib/seedie.rb

@@ -0,0 +1,42 @@
+# 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/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 "seedie/railtie" if defined?(Rails)
+
+require "active_record"
+require "faker"
+require "yaml"
+
+module Seedie
+  class Error < StandardError; end
+  class InvalidFakerMethodError < StandardError; end
+  class UnknownColumnTypeError < StandardError; end
+  class ConfigFileNotFound < StandardError; end
+  class InvalidAssociationConfigError < StandardError; end
+  class InvalidCustomFieldKeysError < StandardError; end
+  class InvalidCustomFieldValuesError < StandardError; end
+  class CustomFieldNotEnoughValuesError < StandardError; end
+  class CustomFieldInvalidPickValueError < StandardError; end
+end