seedie 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 561377deea81325062cee19ab2cd29e48d6d434e2872b97474712c1ab07a4d87
+  data.tar.gz: 06a8f58b9488ec48da96b6678696bbfc672fd71f881395a795a8a97eff4d1478
+SHA512:
+  metadata.gz: eda91d6bd4be5e638ef13e963d517f25055e9a96bbccfd222d565caeed5eddaf929fff9742a45bc260c27cafb5c2f0d37e4d91948c1d7786e17cc10202c05289
+  data.tar.gz: 18f0f86fadc97d6e9be4a736d0795cdf09a6a8df044fd5f6d1a7ae4d1e3f0c75a3be706111b56c5c44bacfaf3f7d072fc5479091f412be6f319591b83616e8c8

data/.rspec

@@ -0,0 +1 @@
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,16 @@
+AllCops:
+  TargetRubyVersion: 2.6
+  DisabledByDefault: true
+  
+Style/StringLiterals:
+  Enabled: true
+  EnforcedStyle: double_quotes
+
+Style/StringLiteralsInInterpolation:
+  Enabled: true
+  EnforcedStyle: double_quotes
+
+Layout/LineLength:
+  Max: 120
+  Exclude:
+    - "spec/dummy/**/*"

data/Gemfile

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in seedie.gemspec
+gemspec
+
+gem "rake", "~> 13.0"
+gem "rubocop", "~> 1.21"
+
+gem "pry", "~> 0.14.2"
+
+group :test do
+  gem "simplecov", "~> 0.22.0", require: false
+end

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2023 Keshav Biswa
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,111 @@
+# Seedie
+
+Seedie is a Ruby gem designed to streamline the seeding of your database.
+Utilizing the Faker library, Seedie generates realistic data for ActiveRecord models.
+Currently supports only PostrgreSQL and SQLite3 databases.
+The gem includes a Rake task for seeding models and a Rails generator for easy setup.
+
+## Installation
+
+Add the following line to your application's Gemfile:
+
+```bash
+gem 'seedie'
+```
+
+And then execute:
+
+```bash
+$ bundle install
+```
+
+Or install it yourself as:
+
+```bash
+$ gem install seedie
+```
+Next, run the install generator:
+
+```bash
+$ rails generate seedie:install
+```
+This will create a seedie.yml file in your config directory, which will include configurations for your models.
+
+## Usage
+
+To seed your models, run the following Rake task:
+
+```bash
+$ rake seedie:seed
+```
+
+This will use the configurations specified in seedie.yml to seed your models.
+
+The seedie.yml file has entries for each model in your application, and you can customize the configuration for each one. 
+
+Here's an example of a more advanced configuration in seedie.yml:
+
+
+```yaml
+default_count: 5
+models:
+  user:
+    attributes:
+      name: "name {{index}}"
+      email: "{{Faker::Internet.email}}"
+      address: "{{Faker::Address.street_address}}"
+    disabled_fields: [nickname password password_digest]
+  post: &post
+    count: 2
+    attributes:
+      title: "title {{index}}"
+    associations:
+      has_many:
+        comments: 4
+      belongs_to:
+        user: random
+      has_one:
+        post_metadatum: 
+          attributes:
+            seo_text: "{{Faker::Lorem.paragraph}}"
+    disabled_fields: []
+  comment:
+    attributes:
+      title: "title {{index}}"
+    associations:
+      belongs_to:
+        post:
+          attributes:
+            title: "Comment Post {{index}}"
+
+```
+
+In this file:
+
+- `default_count` specifies the number of records to be generated for each model when no specific count is provided in the model's configuration.
+- `models` is a hash that contains a configuration for each model that should be seeded.
+- `attributes` is a hash that maps field names to the values that should be used. If attributes are not defined, Seedie will use Faker to generate a value for the field.
+  - The special `{{index}}` placeholder will be replaced by the index of the current record being created, starting from 1. This allows you to have unique values for each record.
+  - Additionally, we can use placeholders like `{{Faker::Internet.email}}` to generate dynamic and unique data for each record using Faker.
+- `disabled_fields` is an array of fields that should not be automatically filled by Seedie.
+- `associations` specify how associated models should be generated. Here, `has_many`, `belongs_to`, and `has_one` are supported.
+- The specified number for `has_many` represents the number of associated records to create.
+- For `belongs_to`, the value `random` means that a random existing record will be associated.
+- If attributes are specified under an association, those attributes will be used when creating the associated record(s)
+- When using associations, it's important to define the models in the correct order in the `seedie.yml` file. Associated models should be defined before the models that reference them.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. 
+Then, run `bundle exec rspec` to run the tests.
+By default, the tests will supress output of the seeds progress.
+Use `DEBUG_OUTPUT=true bundle exec rspec` to see the output of the seeds.
+You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/keshavbiswa/seedie.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+
+desc "Run all examples"
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.ruby_opts = %w[-w]
+  t.rspec_opts = %w[--color]
+end
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: %i[spec rubocop]

data/lib/generators/seedie/USAGE

@@ -0,0 +1,7 @@
+Description:
+  Creates a seedie.yml file in your config directory.
+Example:
+  bin/rails generate seedie:install
+
+  This will create:
+    config/seedie.yml

data/lib/generators/seedie/install_generator.rb

@@ -0,0 +1,136 @@
+require "rails/generators/base"
+require "active_record"
+
+module Seedie
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      EXCLUDED_MODELS = %w[
+        ActiveRecord::SchemaMigration
+        ActiveRecord::InternalMetadata
+        ActiveStorage::Attachment
+        ActiveStorage::Blob
+        ActiveStorage::VariantRecord
+        ActionText::RichText
+        ActionMailbox::InboundEmail
+        ActionText::EncryptedRichText
+      ]
+
+      source_root File.expand_path("templates", __dir__)
+
+      desc "Creates a seedie.yml for your application."
+      def generate_seedie_file(output = STDOUT)
+        Rails.application.eager_load! # Load all models. This is required!!
+
+        @models = get_models
+        @models_config = build_models_config
+        template "seedie.yml", "config/seedie.yml"
+        output_seedie_warning(output)
+      end
+
+      private
+
+
+      def build_models_config
+        models = Model::ModelSorter.new(@models).sort_by_dependency
+        models.reduce({}) do |config, model|
+          config[model.name.underscore] = model_configuration(model)
+          config
+        end
+      end
+
+      def model_configuration(model)
+        attributes_configuration(model).merge(associations_configuration(model))
+      end
+
+      def attributes_configuration(model)
+        active_columns = []
+        disabled_columns = []
+
+        model.columns.each do |column|
+          # Excluding DEFAULT_DISABLED_FIELDS
+          # Excluding foreign_keys, polymorphic associations,
+          # password digest, columns with default functions or values
+          next if ModelFields::DEFAULT_DISABLED_FIELDS.include?(column.name)
+          next if column.name.end_with?("_id", "_type", "_digest")
+          next if column.default_function.present?
+          next if column.default.present?
+      
+          # Only add to active if its required or has presence validator
+          if column.null == false || has_presence_validator?(model, column.name)
+            active_columns << column
+          else
+            disabled_columns << column
+          end
+        end
+
+        # Add atleast one column to active columns
+        active_columns << disabled_columns.pop if active_columns.empty? && disabled_columns.present?
+
+        {
+          "attributes" => active_columns_configuration(model, active_columns),
+          "disabled_fields" => disabled_columns_configuration(disabled_columns)
+        }
+      end
+
+      def active_columns_configuration(model, columns)
+        columns.reduce({}) do |config, column|
+          validations = model.validators_on(column.name)
+          config[column.name] = if validations.present?
+                                  FieldValues::FakerBuilder.new(column.name, column, validations).build_faker_constant
+                                else
+                                  FieldValues::FakeValue.new(column.name, column).generate_fake_value
+                                end
+          config
+        end
+      end
+
+      def disabled_columns_configuration(disabled_columns)
+        disabled_columns.map(&:name)
+      end
+
+      def associations_configuration(model)
+        {
+          "associations" => {
+            "belongs_to" => belongs_to_associations_configuration(model),
+            "has_one" => {}, # TODO: Add has_one associations
+            "has_many" => {}, # TODO: Add has_many associations
+          }
+        }
+      end
+
+      def belongs_to_associations_configuration(model)
+        belongs_to_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
+
+        belongs_to_associations.reduce({}) do |config, association|
+          config[association.name.to_s] = "random"
+          config
+        end
+      end
+
+      def has_presence_validator?(model, column_name)
+        model.validators_on(column_name).any? { |v| v.kind == :presence }
+      end
+
+      def get_models
+        @get_models ||= ActiveRecord::Base.descendants.reject do |model|
+          EXCLUDED_MODELS.include?(model.name) || # Excluded Reserved Models
+          model.abstract_class? || # Excluded Abstract Models
+          model.table_exists? == false || # Excluded Models without tables
+          model.name.blank? || # Excluded Anonymous Models
+          model.name.start_with?("HABTM_") # Excluded HABTM Models
+        end
+      end
+
+      def output_seedie_warning(output)
+        output.puts "Seedie config file generated at config/seedie.yml"
+        output.puts "##################################################"
+        output.puts "WARNING: Please review the generated config file before running the seeds."
+        output.puts "There might be some things that you might need to change to ensure that the generated seeds run successfully."
+        output.puts "##################################################"
+      end
+    end
+  end
+end

data/lib/generators/seedie/templates/seedie.yml

@@ -0,0 +1,26 @@
+default_count: 5
+models:
+<% @models_config.each do |model, config| -%>
+  <%= model %>:
+    attributes:
+<% config['attributes'].each do |name, value| -%>
+<% if value.is_a?(Hash) && value.key?("custom_attr_value") -%>
+      <%= name %>:
+        custom_attr_value:
+          values: <%= value["custom_attr_value"]["values"] %>
+          pick_strategy: <%= value["custom_attr_value"]["pick_strategy"] %>
+<% else -%>
+      <%= name %>: '<%= value %>'
+<% end -%>
+<% end -%>
+    disabled_fields: <%= config['disabled_fields'] %>
+<% if config['associations'] -%>
+    associations:
+<% config['associations'].each do |type, associations| -%>
+      <%= type %>:
+<% associations.each do |association, value| -%>
+        <%= association %>: <%= value %>
+<% end -%>
+<% end -%>
+<% end -%>
+<% end -%>

data/lib/seedie/associations/base_association.rb

@@ -0,0 +1,44 @@
+module Seedie
+  class BaseAssociation
+    include Reporters::Reportable
+    
+    DEFAULT_COUNT = 1
+    INDEX = 0
+
+    attr_reader :record, :model, :association_config, :reporters
+
+    def initialize(record, model, association_config, reporters = [])
+      @record = record
+      @model = model
+      @association_config = association_config
+      @reporters = reporters
+
+      add_observers(@reporters)
+    end
+
+    def generate_associations
+      raise NotImplementedError
+    end
+
+    def generate_association
+      raise NotImplementedError
+    end
+
+    private
+
+    def get_association_count(config)
+      return config if only_count_given?(config)
+      return config["count"] if config["count"].present?
+
+      DEFAULT_COUNT
+    end
+
+    def only_count_given?(config)
+      config.is_a?(Numeric) || config.is_a?(String)
+    end
+
+    def generate_associated_field(id, association_name)
+      { "#{association_name}" => id }
+    end
+  end
+end

data/lib/seedie/associations/belongs_to.rb

@@ -0,0 +1,89 @@
+module Seedie
+  module Associations
+    class BelongsTo < BaseAssociation
+      attr_reader :associated_field_set
+
+      def initialize(model, association_config, reporters = [])
+        super(nil, model, association_config, reporters)
+
+        @associated_field_set = {}
+      end
+
+      def generate_associations
+        return if association_config["belongs_to"].nil?
+        
+        report(:belongs_to_start)
+
+        association_config["belongs_to"].each do |association_name, association_config|
+          reflection = model.reflect_on_association(association_name)
+
+          handle_association_config_type(reflection, association_name, association_config)
+        end
+      end
+
+      def generate_association(klass, config, index)
+        field_values_set = FieldValuesSet.new(klass, config, index).generate_field_values
+
+        Model::Creator.new(klass).create!(field_values_set)
+      end
+
+      private
+
+      def handle_association_config_type(reflection, association_name, association_config)
+        case get_type(association_config)
+        when "random"
+          handle_random_config_type(reflection)
+        when "unique"
+          handle_unique_config_type(reflection)
+        when "new"
+          handle_new_config_type(reflection)
+        else
+          handle_other_config_type(reflection, association_config)
+        end
+      end
+
+      def handle_random_config_type(reflection)
+        klass = reflection.klass
+        id = Model::IdGenerator.new(klass).random_id
+
+        report(:random_association, name: klass.to_s, parent_name: model.to_s, id: id)
+        associated_field_set.merge!(generate_associated_field(id, reflection.foreign_key))
+      end
+
+      def handle_unique_config_type(reflection)
+        klass = reflection.klass
+        report(:unique_association, name: klass.to_s, parent_name: @model.to_s)
+
+        id = Model::IdGenerator.new(klass).unique_id_for(@model)
+        associated_field_set.merge!(generate_associated_field(id, reflection.foreign_key))
+      end
+
+      def handle_new_config_type(reflection)
+        klass = reflection.klass
+        report(:belongs_to_associations, name: klass.to_s, parent_name: model.to_s)
+            
+        new_associated_record = generate_association(klass, {}, INDEX)
+        associated_field_set.merge!(generate_associated_field(new_associated_record.id, reflection.foreign_key))
+      end
+
+      def handle_other_config_type(reflection, association_config)
+        klass = reflection.klass
+
+        report(:belongs_to_associations, name: klass.to_s, parent_name: model.to_s)
+            
+        new_associated_record = generate_association(klass, association_config, INDEX)
+        associated_field_set.merge!(generate_associated_field(new_associated_record.id, reflection.foreign_key))
+      end
+
+      def get_type(association_config)
+        if association_config.is_a?(String)
+          raise InvalidAssociationConfigError, "Invalid association config" unless ["random", "new", "unique"].include?(association_config)
+
+          return association_config
+        else
+          association_config
+        end
+      end
+    end
+  end
+end

data/lib/seedie/associations/has_many.rb

@@ -0,0 +1,24 @@
+module Seedie
+  module Associations
+    class HasMany < BaseAssociation
+      def generate_associations
+        return if association_config["has_many"].nil?
+        
+        report(:has_many_start)
+        association_config["has_many"].each do |association_name, association_config|
+          association_class = association_name.to_s.classify.constantize
+          count = get_association_count(association_config)
+          config = only_count_given?(association_config) ? {} : association_config
+          
+          report(:associated_records, name: association_name, count: count, parent_name: model.to_s)
+          count.times do |index|
+            field_values_set = FieldValuesSet.new(association_class, config, index).generate_field_values
+            record_creator = Model::Creator.new(record.send(association_name), reporters)
+
+            record_creator.create!(field_values_set)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/seedie/associations/has_one.rb

@@ -0,0 +1,29 @@
+module Seedie
+  module Associations
+    class HasOne < BaseAssociation
+      def generate_associations
+        return if association_config["has_one"].nil?
+
+        report(:has_one_start)
+        
+        association_config["has_one"].each do |association_name, association_config|
+          reflection = model.reflect_on_association(association_name)
+          association_class = reflection.klass
+          count = get_association_count(association_config)
+          
+          report(:associated_records, count: count, name: association_name, parent_name: model.to_s)
+          if count > 1
+            raise InvalidAssociationConfigError, "has_one association cannot be more than 1"
+          else
+            config = only_count_given?(association_config) ? {} : association_config
+            field_values_set = FieldValuesSet.new(association_class, config, INDEX).generate_field_values
+            parent_field_set = generate_associated_field(record.id, reflection.foreign_key)
+            
+            record_creator = Model::Creator.new(association_class, reporters)
+            record_creator.create!(field_values_set.merge!(parent_field_set))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/seedie/field_values/custom_value.rb

@@ -0,0 +1,97 @@
+module Seedie
+  module FieldValues
+    class CustomValue
+      VALID_KEYS = ["values", "pick_strategy"]
+      CUSTOM_VALUE = "custom_attr_value"
+
+      attr_reader :name, :parsed_value
+
+      def initialize(name, value_template, index)
+        @name = name
+        @value_template = value_template
+        @index = index
+        @parsed_value = ""
+        @custom_attr_value = false
+        
+        validate_template if @value_template.is_a?(Hash) && @value_template.has_key?(CUSTOM_VALUE)
+      end
+
+      def generate_custom_field_value
+        if @value_template.is_a?(String)
+          generate_custom_value_from_string
+        else
+          generate_custom_value_from_hash
+        end
+
+        parsed_value
+      end
+
+      private
+
+      def validate_template
+        @value_template = @value_template[CUSTOM_VALUE]
+        @custom_attr_value = true
+
+        validate_hash_keys
+        validate_values_key
+        validate_pick_strategy_key
+      end
+
+      def validate_hash_keys
+        invalid_keys = @value_template.keys - VALID_KEYS
+        return if invalid_keys.empty?
+
+        raise InvalidCustomFieldKeysError, 
+          "Invalid keys for #{@name}: #{invalid_keys.join(", ")}. Only 'values' and 'pick_strategy' are allowed."
+      end
+
+      def validate_values_key
+        return if @value_template["values"].is_a?(Array)
+
+        raise InvalidCustomFieldValuesError, "The values key for #{@name} must be an array."
+      end
+
+      def validate_values_length
+        return if @value_template["values"].length >= @index
+
+        raise CustomFieldNotEnoughValuesError, "There are not enough values for name. Please add more values."
+      end
+
+      def validate_pick_strategy_key
+        @pick_strategy = @value_template["pick_strategy"] || "random"
+        return if %w[random sequential].include?(@pick_strategy)
+
+        raise CustomFieldInvalidPickValueError, "The pick_strategy for #{@name} must be either 'sequential' or 'random'."
+      end
+
+      def generate_custom_value_from_string
+        @parsed_value = @value_template.gsub("{{index}}", @index.to_s)
+
+        @parsed_value.gsub!(/\{\{(.+?)\}\}/) do
+          method_string = $1
+
+          if method_string.start_with?("Faker::")
+            eval($1)
+          else
+            raise InvalidFakerMethodError, "Invalid method: #{method_string}"
+          end
+        end
+      end
+
+      def generate_custom_value_from_hash
+        if @custom_attr_value
+          values = @value_template["values"]
+          if @pick_strategy == "sequential"
+            validate_values_length
+
+            @parsed_value = values[@index]
+          else
+            @parsed_value = values.sample
+          end
+        else
+          @parsed_value = @value_template
+        end
+      end
+    end
+  end
+end