seedie 0.1.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3c94e296c2303e454021934b3891b47e0b0974217e1df8bcbc7178f1c6b71452
-  data.tar.gz: a9c447bafa471eb10123209fdaa245a587cbf9ed1ef7ee56d07b875a719f40fc
+  metadata.gz: fa80b46ccb1727a4451598e8f94657bc15b43dbb0b2b0e58e8bd744db0636af6
+  data.tar.gz: b8e49e8fecdbc3c63f62b55384e3860428c9eb579114552cc2da7212c1e4b92c
 SHA512:
-  metadata.gz: 0b423fde9186493e8b83febbbda6abd4b7b25966fcde1396e67d0af6011f28e4f0fbf67cae25d9a30293aba0668cdf794a73c080c2becb796a876094b19523ef
-  data.tar.gz: 2eaca5df71b6721becf3e61497d828ff8524822de1e79ba3d5c9bc8bbf6d8d2a18f0913eca1e1ad4db6055df726af0c85573f07f7c56535fc8790a97f244c51b
+  metadata.gz: fd0263009e5cd4b9d2287d56bde4ee2eb93337019218e018960efb9e5c9206b9f0323ccec95eaa986ddb9257d4acc9ccf684906f3f56319e1536fb6018201c4a
+  data.tar.gz: '0808e17b7a47e12367491571ade529974202d48eb0d93a0885143dba3e4b2982db13cac4a2196e478e39770d120cf4cd632b4436934d649f23e9f2f651263684'

data/CHANGELOG.md

@@ -0,0 +1,127 @@
+## Version 0.3.0
+
+### New Features
+
+#### Generate a Blank Seedie.yml file with `--blank` option
+
+* [GitHub PR](https://github.com/keshavbiswa/seedie/pull/20)
+
+  You can now generate a blank seedie.yml file with the `--blank` option:
+
+  ```bash
+  rails g seedie:install --blank
+  ```
+
+#### Exclude models from seedie.yml generation with `--excluded_models` option
+
+* [GitHub PR](https://github.com/keshavbiswa/seedie/pull/21)
+
+  You can now exclude models from seedie.yml generation with the `--excluded_models` option:
+
+  ```bash
+  rails g seedie:install --excluded_models Post Comment
+  ```
+
+#### Generate a Seedie.yml file with only specific models with `--include_only_models` option
+
+* [GitHub PR](https://github.com/keshavbiswa/seedie/pull/22)
+
+  You can now generate a seedie.yml file with only specific models with the `--include_only_models` option:
+
+  ```bash
+  rails g seedie:install --include_only_models Post Comment
+  ```
+
+#### Bugfix: Now unique indexes will be generated with `unique` instead of `random` pick_strategy
+
+* [GitHub PR](https://github.com/keshavbiswa/seedie/pull/23)
+
+#### Introducing new Seedie.rb initializer
+
+* [GitHub PR](https://github.com/keshavbiswa/seedie/pull/28)
+* [GitHub PR](https://github.com/keshavbiswa/seedie/pull/29)
+
+```ruby
+Seedie.configure do |config|
+  # config.default_count = 10
+
+  config.custom_attributes[:email] = "{{Faker::Internet.unique.email}}"
+  # Add more custom attributes here
+end
+```
+
+## Version 0.2.0
+
+### New Features
+
+#### Polymorphic Association
+* [GitHub PR](https://github.com/keshavbiswa/seedie/pull/12)
+  
+  You can now add a polymorphic association to your seedie.yml file:
+  
+  ```yaml
+  belongs_to:
+    commentable:
+      polymorphic: post # or [post, article] for multiple options
+      strategy: random
+  ```
+
+#### Automatic Polymorphic Association Generator
+* [GitHub PR](https://github.com/keshavbiswa/seedie/pull/13)
+
+  When you run `rails g seedie:install`, it'll also generate the necessary polymorphic associations.
+
+#### Custom Value Attributes with Validations
+* [GitHub PR](https://github.com/keshavbiswa/seedie/pull/14)
+
+  Replaced custom_attr_value with a simplified value key:
+
+  Before:
+  ```yaml
+  some_attribute:
+    custom_attr_value:
+      values: [1,2,3]
+      pick_strategy: random
+  ```
+
+  After:
+  ```yaml
+  some_attribute:
+    values: [1,2,3] # or value (in which case pick_strategy is not required)
+    options:
+      pick_strategy: random
+  ```
+
+#### Custom Value Generator
+
+* [GitHub PR](https://github.com/keshavbiswa/seedie/pull/17)
+  
+  Upon invoking `rails g seedie:install`, the generator will also add custom values.
+
+#### Inclusion of Non-polymorphic _type Columns
+* [Github PR](https://github.com/keshavbiswa/seedie/pull/18)
+
+  Earlier, columns with `_type` were skipped during seedie.yml generation, causing some attributes to be overlooked.
+
+  ```ruby
+  class User < ApplicationRecord
+    enum role_type: { admin: 0, user: 1 }
+  end
+  ```
+
+  We've resolved this, now only columns related to polymorphic foreign_types are excluded.
+
+#### Range Inclusions
+* [Github PR](https://github.com/keshavbiswa/seedie/pull/19)
+
+  Define ranges using the start and end keys:
+
+  ```yaml
+  score:
+    values: 
+      start: 0
+      end: 100
+    options: { pick_strategy: sequential }
+  ```
+
+  This configuration will generate sequential numbers between 0 and 100.

data/README.md

@@ -34,8 +34,77 @@ $ rails generate seedie:install
 ```
 This will create a seedie.yml file in your config directory, which will include configurations for your models.
 
+Alternatively, you can also create a blank seedie.yml file by running:
+
+```bash
+$ rails generate seedie:install --blank
+```
+
+This will generate a blank seedie.yml config file for you that you can now customize according to your needs.
+
 ## Usage
 
+### Generating blank seedie.yml
+If you want to create a blank seedie.yml file, use the `--blank` option:
+
+```bash
+$ rails generate seedie:install --blank
+```
+
+This will generate a blank seedie.yml config file for you that you can now customize according to your needs.
+
+### Excluding Models
+If you want to exclude certain models while generating the `seedie.yml`, use the `--exclude_models` option:
+
+```bash
+$ rails generate seedie:install --exclude_models User Admin Post
+```
+
+NOTE: Some models may not be excluded because of their dependencies. For example, if you have a model `Post` that belongs to a model `User`, then the `User` model will not be excluded even if you specify it in the `--exclude_models` option.
+
+You'll get a warning in your console if any models are not excluded:
+
+```bash
+WARNING: User has dependencies with other models and cannot be excluded.
+```
+
+### Including only few Models
+If you want to include only few particular models while generating the `seedie.yml`, use the `--include_only_models` option:
+
+```bash
+$ rails generate seedie:install --include_only_models Post Comment
+```
+
+NOTE: Some models may be a dependency for the required models and will need to be included for successful seeding. For example, if you have a model `Post` that belongs to a model `User`, then the `User` model will need to be included even if you didn't specify it in the `--include_only_models` option.
+
+You'll get a warning in your console if any other models are included:
+
+```bash
+WARNING: User is a dependency of included models and needs to be included.
+```
+
+### Add Custom Attributes inside seedie.rb initializer
+
+While generating the seedie.yml file, there are default values.
+For example, for every `string` field, the default value is `{{Faker::Lorem.word}}`.
+This works fine for most attributes, but for some there are validations which breaks the seeding.
+Take `email` as an example, the default value `{{Faker::Lorem.word}}` will not be a valid email.
+By default, when we generate the seedie.yml file, we add a `seedie.rb` initializer file in the `config/initializers` directory.
+
+```ruby
+Seedie.configure do |config|
+  # config.default_count = 10
+
+  config.custom_attributes[:email] = "{{Faker::Internet.unique.email}}"
+  # Add more custom attributes here
+end
+```
+
+This ensures that the `email` field is seeded with a valid email address.
+You can add more custom attributes in the `seedie.rb` initializer file.
+
+### Seeding Models
+
 To seed your models, run the following Rake task:
 
 ```bash
@@ -63,8 +132,8 @@ models:
     attributes:
       title: "title {{index}}"
       category:
-        custom_attr_value:
-          values: [tech, sports, politics, entertainment]
+        values: [tech, sports, politics, entertainment]
+        options: 
           pick_strategy: random # or sequential
     associations:
       has_many:
@@ -98,7 +167,7 @@ In this file:
 - `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.
+- For `belongs_to`, the value `random` means that a random existing record will be associated. If there is a unique index associated, then `unique` will be set or else `random` is the default.
 - 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.
 

data/lib/generators/seedie/install_generator.rb

@@ -1,9 +1,11 @@
 require "rails/generators/base"
-require "active_record"
+require "seedie"
 
 module Seedie
   module Generators
     class InstallGenerator < Rails::Generators::Base
+      include PolymorphicAssociationHelper
+      
       EXCLUDED_MODELS = %w[
         ActiveRecord::SchemaMigration
         ActiveRecord::InternalMetadata
@@ -17,21 +19,44 @@ module Seedie
 
       source_root File.expand_path("templates", __dir__)
 
+      class_option :blank, type: :boolean, default: false, desc: "Generate a blank seedie.yml with examples"
+      class_option :excluded_models, type: :array, default: [], desc: "Models to exclude from seedie.yml"
+      class_option :include_only_models, type: :array, default: [], 
+        desc: "Models to be specifically included in seedie.yml. This will ignore all other models."
+
+
       desc "Creates a seedie.yml for your application."
       def generate_seedie_file(output = STDOUT)
-        Rails.application.eager_load! # Load all models. This is required!!
+        if options[:include_only_models].present? && options[:excluded_models].present?
+          raise ArgumentError, "Cannot use both --include_only_models and --excluded_models together." 
+        end
+        
+        # This needs to be generated before anything else.
+        template "seedie_initializer.rb", "config/initializers/seedie.rb"
+        
+        @excluded_models = options[:excluded_models] + EXCLUDED_MODELS
+        @output = output
+
+        if options[:blank]
+          template "blank_seedie.yml", "config/seedie.yml"
+        else
+          Rails.application.eager_load! # Load all models. This is required!!
+
+          @models = get_models
+          @models_config = build_models_config
+          template "seedie.yml", "config/seedie.yml"
+        end
 
-        @models = get_models
-        @models_config = build_models_config
-        template "seedie.yml", "config/seedie.yml"
-        output_seedie_warning(output)
+        output_seedie_warning
       end
 
       private
 
-
       def build_models_config
         models = Model::ModelSorter.new(@models).sort_by_dependency
+
+        output_warning_for_extra_models(models)
+
         models.reduce({}) do |config, model|
           config[model.name.underscore] = model_configuration(model)
           config
@@ -45,18 +70,32 @@ module Seedie
       def attributes_configuration(model)
         active_columns = []
         disabled_columns = []
+        default_columns = []
+        foreign_keys = []
+        polymorphic_types = []
+
+        # Collect all foreign keys and polymorphic types
+        model.reflect_on_all_associations.each do |assoc|
+          foreign_keys << assoc.foreign_key
+          polymorphic_types << assoc.foreign_type if assoc.options[:polymorphic]
+        end
 
         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?
-      
+          next if column.name.end_with?("_id", "_digest")
+
+          if polymorphic_types.include?(column.name) || foreign_keys.include?(column.name)
+            next
+          end
+          
+          # Adding default columns to default_columns
+          if column.default.present? || column.default_function.present?
+            default_columns << column
+          elsif column.null == false || has_presence_validator?(model, column.name)
           # 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
@@ -65,6 +104,9 @@ module Seedie
 
         # Add atleast one column to active columns
         active_columns << disabled_columns.pop if active_columns.empty? && disabled_columns.present?
+        
+        # Disable all default columns
+        disabled_columns += default_columns
 
         {
           "attributes" => active_columns_configuration(model, active_columns),
@@ -100,14 +142,27 @@ module Seedie
 
       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
 
+        unique_indexes = model.connection.indexes(model.table_name).select(&:unique).flat_map(&:columns)
+
         belongs_to_associations.reduce({}) do |config, association|
-          config[association.name.to_s] = "random"
+          if association.polymorphic?
+            config[association.name.to_s] = set_polymorphic_association_config(model, association)
+          else
+            association_has_unique_index = unique_indexes.include?(association.foreign_key.to_s)
+            config[association.name.to_s] = association_has_unique_index ? "unique" : "random"
+          end
           config
         end
+      end      
+      
+      def set_polymorphic_association_config(model, association)
+        {
+          "polymorphic" => find_polymorphic_types(model, association.name),
+          "strategy" => "random"
+        }
       end
 
       def has_presence_validator?(model, column_name)
@@ -115,21 +170,45 @@ module Seedie
       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
+        @get_models ||= begin
+          all_models = ActiveRecord::Base.descendants
+
+          if options[:include_only_models].present?
+            all_models.select! { |model| options[:include_only_models].include?(model.name) }
+          end
+
+          all_models.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
       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 "##################################################"
+      def output_seedie_warning
+        @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
+
+      def output_warning_for_extra_models(models)
+        if options[:excluded_models].present?
+          required_excluded_models = models.map(&:name) & @excluded_models
+
+          required_excluded_models.each do |model_name|
+            @output.puts "WARNING: #{model_name} has dependencies with other models and cannot be excluded."
+          end
+        elsif options[:include_only_models].present?
+          dependent_models = models.map(&:name) - @models.map(&:name)
+
+          dependent_models.each do |model_name|
+            @output.puts "WARNING: #{model_name} is a dependency of included models and needs to be included."
+          end
+        end
       end
     end
   end

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

@@ -0,0 +1,22 @@
+### This is a blank seedie.yml file. ###
+
+# default_count: 10
+#
+# models:
+#   model_name:
+#     attributes:
+#       string_field: '{{Faker::Lorem.word}}'
+#       integer_field:
+#         values: [1, 2, 3]
+#         options: 
+#           pick_strategy: random
+#       jsonb_field:
+#         value: '{"key": "value"}'
+#     disabled_fields: ["unwanted_field"]
+#     associations:
+#       belongs_to:
+#         parent_model: random
+#       has_one:
+#         associated_model: random
+#       has_many:
+#         other_models: random

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

@@ -4,11 +4,26 @@ models:
   <%= model %>:
     attributes:
 <% config['attributes'].each do |name, value| -%>
-<% if value.is_a?(Hash) && value.key?("custom_attr_value") -%>
+<% if value.is_a?(Hash) -%>
       <%= name %>:
-        custom_attr_value:
-          values: <%= value["custom_attr_value"]["values"] %>
-          pick_strategy: <%= value["custom_attr_value"]["pick_strategy"] %>
+<% if value['values'] -%>
+<% if value['values'].is_a?(Array) -%>
+        values: <%= value['values'] %>
+<% elsif value['values'].is_a?(Hash) -%>
+        values:
+<% value['values'].each do |key, value| -%>
+          <%= key %>: <%= value %>
+<% end -%>
+<% end -%>
+<% elsif value['value'] -%>
+        value: '<%= value['value'] %>'
+<% end -%>
+<% if value['options'] -%>
+        options: 
+<% value['options'].each do |key, value| -%>
+          <%= key %>: '<%= value %>'
+<% end -%>
+<% end -%>
 <% else -%>
       <%= name %>: '<%= value %>'
 <% end -%>
@@ -19,8 +34,15 @@ models:
 <% config['associations'].each do |type, associations| -%>
       <%= type %>:
 <% associations.each do |association, value| -%>
+<% if value.is_a?(Hash) && value.key?("polymorphic") -%>
+<% next if value["polymorphic"].blank? -%>
+        <%= association %>:
+          polymorphic: <%= value["polymorphic"] %>
+          strategy: <%= value["strategy"] %>
+<% else -%>
         <%= association %>: <%= value %>
 <% end -%>
 <% end -%>
 <% end -%>
 <% end -%>
+<% end -%>

data/lib/generators/seedie/templates/seedie_initializer.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+Seedie.configure do |config|
+  # config.default_count = 10
+
+  config.custom_attributes[:email] = "{{Faker::Internet.unique.email}}"
+  # Add more custom attributes here
+end

data/lib/seedie/associations/belongs_to.rb

@@ -30,45 +30,71 @@ module Seedie
       private
 
       def handle_association_config_type(reflection, association_name, association_config)
-        case get_type(association_config)
+        if reflection.polymorphic?
+          handle_polymorphic_config_type(reflection, association_config)
+        else
+          klass = reflection.klass
+          strategy = get_type(association_config)
+          handle_strategy(klass, reflection, strategy)
+        end
+      end
+      
+
+      def handle_polymorphic_config_type(reflection, association_config)
+        type_name = get_polymorphic_class_name(association_config["polymorphic"])
+        klass = type_name.classify.constantize
+        strategy = get_type(association_config["strategy"])
+        associated_field_set.merge!(generate_associated_field(klass.to_s, reflection.foreign_type))
+
+        handle_strategy(klass, reflection, strategy)
+      end
+      
+      # Handles the strategy for belongs_to associations
+      # For polymorphic reflection, we might not add a strategy
+      # so we need to default it to random
+      def handle_strategy(klass, reflection, strategy)
+        strategy ||= reflection.polymorphic? ? "random" : nil
+
+        case get_type(strategy)
         when "random"
-          handle_random_config_type(reflection)
+          handle_random_config_type(klass, reflection)
         when "unique"
-          handle_unique_config_type(reflection)
+          handle_unique_config_type(klass, reflection)
         when "new"
-          handle_new_config_type(reflection)
+          handle_new_config_type(klass, reflection)
         else
-          handle_other_config_type(reflection, association_config)
+          handle_other_config_type(klass, reflection, strategy)
         end
       end
 
-      def handle_random_config_type(reflection)
-        klass = reflection.klass
+      # polymorphic option can either be single value "post" or an array ["post", "game_room"]
+      # type pick strategy will be either the single value or a random value from the array
+      def get_polymorphic_class_name(polymorphic_types)
+        polymorphic_types.is_a?(String) ? polymorphic_types : polymorphic_types.sample
+      end
+
+      def handle_random_config_type(klass, reflection)
         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
+      def handle_unique_config_type(klass, reflection)
         report(:unique_association, name: klass.to_s, parent_name: @model.to_s)
 
-        id = Model::IdGenerator.new(klass).unique_id_for(@model)
+        id = Model::IdGenerator.new(klass).unique_id_for(@model, reflection.foreign_key)
         associated_field_set.merge!(generate_associated_field(id, reflection.foreign_key))
       end
 
-      def handle_new_config_type(reflection)
-        klass = reflection.klass
+      def handle_new_config_type(klass, reflection)
         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
-
+      def handle_other_config_type(klass, reflection, association_config)
         report(:belongs_to_associations, name: klass.to_s, parent_name: model.to_s)
             
         new_associated_record = generate_association(klass, association_config, INDEX)

data/lib/seedie/configuration.rb

@@ -0,0 +1,10 @@
+module Seedie
+  class Configuration
+    attr_accessor :default_count, :custom_attributes
+
+    def initialize
+      @default_count = nil
+      @custom_attributes = {}
+    end
+  end
+end

data/lib/seedie/field_values/custom_value.rb

@@ -1,9 +1,9 @@
 module Seedie
   module FieldValues
     class CustomValue
-      VALID_KEYS = ["values", "pick_strategy"]
-      CUSTOM_VALUE = "custom_attr_value"
-
+      VALID_KEYS = ["values", "value", "options"].freeze
+      PICK_STRATEGIES = ["random", "sequential"].freeze
+      
       attr_reader :name, :parsed_value
 
       def initialize(name, value_template, index)
@@ -11,9 +11,8 @@ module Seedie
         @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)
+
+        validate_value_template
       end
 
       def generate_custom_field_value
@@ -28,40 +27,77 @@ module Seedie
 
       private
 
-      def validate_template
-        @value_template = @value_template[CUSTOM_VALUE]
-        @custom_attr_value = true
+      def validate_value_template
+        return unless @value_template.is_a?(Hash)
 
-        validate_hash_keys
-        validate_values_key
-        validate_pick_strategy_key
+        validate_keys
+        validate_values if @value_template.key?("values")
+        validate_options if @value_template.key?("options")
       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."
+      def validate_values
+        values = @value_template["values"]
+        options = @value_template["options"]
+        
+        if values.is_a?(Array) || values.is_a?(Hash)
+          validate_sequential_values_length
+        else
+          raise InvalidCustomFieldValuesError, "The values key for #{@name} must be an array or a hash with start and end keys."
+        end
       end
 
-      def validate_values_key
-        return if @value_template["values"].is_a?(Array)
+      def validate_options
+        options = @value_template["options"]
+        pick_strategy = options["pick_strategy"]
 
-        raise InvalidCustomFieldValuesError, "The values key for #{@name} must be an array."
+        if pick_strategy.present? && !PICK_STRATEGIES.include?(pick_strategy)
+          raise InvalidCustomFieldOptionsError,
+            "The pick_strategy for #{@name} must be either 'sequential' or 'random'."
+        end
       end
 
-      def validate_values_length
-        return if @value_template["values"].length >= @index
+      ## 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"]
+
+        if values.is_a?(Hash) && values.keys.sort == ["end", "start"]
+          # Assuming the values are an inclusive range
+          values_length = values["end"] - values["start"] + 1
+        else
+          values_length = values.length
+        end
 
-        raise CustomFieldNotEnoughValuesError, "There are not enough values for name. Please add more values."
+        if values_length < @index + 1
+          raise CustomFieldNotEnoughValuesError,
+            "There are not enough values for #{@name}. Please add more values."
+        end
       end
 
-      def validate_pick_strategy_key
-        @pick_strategy = @value_template["pick_strategy"] || "random"
-        return if %w[random sequential].include?(@pick_strategy)
+      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
+
+        if @value_template.key?("values") 
+          if @value_template.key?("value")
+            raise InvalidCustomFieldKeysError,
+              "Invalid keys for #{@name}: values and value cannot be used together."
+          end
 
-        raise CustomFieldInvalidPickValueError, "The pick_strategy for #{@name} must be either 'sequential' or 'random'."
+          if @value_template["values"].is_a?(Hash)
+            if !@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
+          end
+        end
       end
 
       def generate_custom_value_from_string
@@ -79,19 +115,28 @@ module Seedie
       end
 
       def generate_custom_value_from_hash
-        if @custom_attr_value
-          values = @value_template["values"]
-          if @pick_strategy == "sequential"
-            validate_values_length
-
+        if @value_template.key?("values")
+          values =  if @value_template["values"].is_a?(Array)
+                      @value_template["values"]
+                    else
+                      # generate_custom_value_from_range
+                      generate_custom_values_from_range(@value_template["values"]["start"], @value_template["values"]["end"])
+                    end
+          options = @value_template["options"]
+          
+          if options.present? && options["pick_strategy"] == "sequential"
             @parsed_value = values[@index]
           else
             @parsed_value = values.sample
           end
-        else
-          @parsed_value = @value_template
+        elsif @value_template.key?("value")
+          @parsed_value = @value_template["value"]
         end
       end
+
+      def generate_custom_values_from_range(start, ending)
+        (start..ending).to_a
+      end
     end
   end
 end

data/lib/seedie/field_values/fake_value.rb

@@ -25,7 +25,7 @@ module Seedie
         when :boolean
           Faker::Boolean.boolean
         when :json, :jsonb
-          { "key1" => Faker::Lorem.word, "key2" => Faker::Number.number(digits: 2) }
+          { "value" => { "key1" => Faker::Lorem.word, "key2" => Faker::Number.number(digits: 2) } }
         when :inet
           Faker::Internet.ip_v4_address
         when :cidr, :macaddr
@@ -37,7 +37,7 @@ module Seedie
         when :money
           Faker::Commerce.price.to_s
         when :hstore
-          { "key1" => Faker::Lorem.word, "key2" => Faker::Number.number(digits: 2) }
+          { "value" => { "key1" => Faker::Lorem.word, "key2" => Faker::Number.number(digits: 2) } }
         when :year
           rand(1901..2155)
         else

data/lib/seedie/field_values/faker_builder.rb

@@ -10,9 +10,12 @@ module Seedie
         @class_prefix = ""
         @method_prefix = ""
         @options = ""
+        @seedie_config_custom_attributes = Seedie.configuration.custom_attributes
       end
 
       def build_faker_constant
+        return @seedie_config_custom_attributes[@name.to_sym] if @seedie_config_custom_attributes.key?(@name.to_sym)
+
         @unique_prefix = "unique." if has_validation?(:uniqueness)
         
         add_faker_class_and_method(@column.type)
@@ -62,8 +65,7 @@ module Seedie
           @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)\" })"
+          @faker_expression = { "value" => "Json.shallow_json(width: 3, options: { key: 'Name.first_name', value: 'Number.number(digits: 2)' })" }
         when :inet
           @class_prefix = "Internet."
           @method_prefix = "ip_v4_address"
@@ -80,9 +82,7 @@ module Seedie
           @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)\" })"
+          @faker_expression = { "value" => "Json.shallow_json(width: 3, options: { key: 'Name.first_name', value: 'Number.number(digits: 2)' })" }
         when :year
           @class_prefix = "Number."
           @method_prefix = "number"
@@ -131,7 +131,11 @@ module Seedie
         @class_prefix = ""
         @method_prefix = ""
         @options = ""
-        @faker_expression = { "custom_attr_value" => { "values" => options[:in], "pick_strategy" => "random" } }
+        if options[:in].is_a?(Range)
+          @faker_expression = { "values" => { "start" => options[:in].first, "end" => options[:in].last }, "options" => { "pick_strategy" => "random" } }
+        else
+          @faker_expression = { "values" => options[:in], "options" => { "pick_strategy" => "random" } }
+        end
       end
     end
   end

data/lib/seedie/model/id_generator.rb

@@ -12,9 +12,7 @@ module Seedie
         return id
       end
       
-      def unique_id_for(association_klass)
-        model_id_column = "#{@model.to_s.underscore}_id"
-      
+      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}" 
         end

data/lib/seedie/model/model_sorter.rb

@@ -1,6 +1,8 @@
 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
@@ -20,7 +22,6 @@ module Seedie
     
       private
 
-
       # Independent models need to be added first
       def add_independent_models_to_queue
         @models.each do |model|
@@ -51,7 +52,6 @@ module Seedie
     
       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
       
@@ -60,10 +60,17 @@ module Seedie
         associations.map do |association|
           if association.options[:class_name]
             constantize_class_name(association.options[:class_name], model.name)
+          elsif association.polymorphic?
+            types = find_polymorphic_types(model, association.name)
+
+            if types.blank?
+              puts "Polymorphic type not found for #{model.name}. Ignoring..." 
+              next
+            end
           else
             association.klass
           end
-        end
+        end.compact
       end
 
       private

data/lib/seedie/polymorphic_association_helper.rb

@@ -0,0 +1,20 @@
+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

data/lib/seedie/version.rb

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

data/lib/seedie.rb

@@ -11,6 +11,8 @@ 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"
@@ -22,6 +24,7 @@ require_relative "seedie/associations/belongs_to"
 
 require_relative "seedie/seeder"
 require_relative "seedie/version"
+require_relative "seedie/configuration"
 
 require "seedie/railtie" if defined?(Rails)
 
@@ -37,6 +40,16 @@ module Seedie
   class InvalidAssociationConfigError < StandardError; end
   class InvalidCustomFieldKeysError < StandardError; end
   class InvalidCustomFieldValuesError < StandardError; end
+  class InvalidCustomFieldOptionsError < StandardError; end
   class CustomFieldNotEnoughValuesError < StandardError; end
-  class CustomFieldInvalidPickValueError < StandardError; end
+
+  class << self
+    def configure
+      yield configuration if block_given?
+    end
+
+    def configuration
+      @configuration ||= Configuration.new
+    end
+  end
 end

metadata

@@ -1,27 +1,27 @@
 --- !ruby/object:Gem::Specification
 name: seedie
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.3.0
 platform: ruby
 authors:
 - Keshav Biswa
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-07-30 00:00:00.000000000 Z
+date: 2023-10-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faker
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '2.9'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '2.9'
 - !ruby/object:Gem::Dependency
@@ -118,18 +118,22 @@ extra_rdoc_files: []
 files:
 - ".rspec"
 - ".rubocop.yml"
+- CHANGELOG.md
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
 - lib/generators/seedie/USAGE
 - lib/generators/seedie/install_generator.rb
+- lib/generators/seedie/templates/blank_seedie.yml
 - lib/generators/seedie/templates/seedie.yml
+- lib/generators/seedie/templates/seedie_initializer.rb
 - lib/seedie.rb
 - lib/seedie/associations/base_association.rb
 - lib/seedie/associations/belongs_to.rb
 - lib/seedie/associations/has_many.rb
 - lib/seedie/associations/has_one.rb
+- lib/seedie/configuration.rb
 - lib/seedie/field_values/custom_value.rb
 - lib/seedie/field_values/fake_value.rb
 - lib/seedie/field_values/faker_builder.rb
@@ -139,6 +143,7 @@ files:
 - lib/seedie/model/model_sorter.rb
 - lib/seedie/model_fields.rb
 - lib/seedie/model_seeder.rb
+- lib/seedie/polymorphic_association_helper.rb
 - lib/seedie/railtie.rb
 - lib/seedie/reporters/base_reporter.rb
 - lib/seedie/reporters/console_reporter.rb