seedie 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3c94e296c2303e454021934b3891b47e0b0974217e1df8bcbc7178f1c6b71452
-  data.tar.gz: a9c447bafa471eb10123209fdaa245a587cbf9ed1ef7ee56d07b875a719f40fc
+  metadata.gz: dba945f1f8d911d59194de8191ef857885bc79fb3986fe4d159bbf21842758d9
+  data.tar.gz: 330174e781fa44b766d1fdcc4fbca9b4cc4f549db447913a60e2c1a41a4f0f51
 SHA512:
-  metadata.gz: 0b423fde9186493e8b83febbbda6abd4b7b25966fcde1396e67d0af6011f28e4f0fbf67cae25d9a30293aba0668cdf794a73c080c2becb796a876094b19523ef
-  data.tar.gz: 2eaca5df71b6721becf3e61497d828ff8524822de1e79ba3d5c9bc8bbf6d8d2a18f0913eca1e1ad4db6055df726af0c85573f07f7c56535fc8790a97f244c51b
+  metadata.gz: 4717460bd7dc315de646b3e839f5d8be92881245638711c790b5f8a8b3dac216d8ab0eccf8c6d3bc974f7c9ecf1f00b8520bbf44f6b112af18e2620a44faee71
+  data.tar.gz: cc648a856d662822565da6d648f16d5f17da1f9b5f1eca45f0e2748fc8633e98d7018efda18d699af4771315b424fa83d13b397a632716a06d79910ee4ec4ae9

data/CHANGELOG.md

@@ -0,0 +1,75 @@
+## Version 0.3.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

@@ -63,8 +63,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:

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
@@ -24,6 +26,7 @@ module Seedie
         @models = get_models
         @models_config = build_models_config
         template "seedie.yml", "config/seedie.yml"
+
         output_seedie_warning(output)
       end
 
@@ -45,18 +48,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 +82,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 +120,24 @@ 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
 
         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
+            config[association.name.to_s] = "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)

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/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/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

@@ -62,8 +62,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 +79,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 +128,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
@@ -51,7 +53,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 +61,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.2.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"
@@ -37,6 +39,6 @@ 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
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: seedie
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Keshav Biswa
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-07-30 00:00:00.000000000 Z
+date: 2023-08-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faker
@@ -118,6 +118,7 @@ extra_rdoc_files: []
 files:
 - ".rspec"
 - ".rubocop.yml"
+- CHANGELOG.md
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -139,6 +140,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