seedie 0.3.0 → 0.4.1

data/lib/seedie/associations/has_and_belongs_to_many.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Seedie
+  module Associations
+    class HasAndBelongsToMany < BaseAssociation
+      def generate_associations
+        return if association_config["has_and_belongs_to_many"].nil?
+
+        report(:has_and_belongs_to_many_start)
+        association_config["has_and_belongs_to_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_with_associations
+            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_many.rb

@@ -1,18 +1,20 @@
+# frozen_string_literal: true
+
 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
+            field_values_set = FieldValuesSet.new(association_class, config, index).generate_field_values_with_associations
             record_creator = Model::Creator.new(record.send(association_name), reporters)
 
             record_creator.create!(field_values_set)
@@ -21,4 +23,4 @@ module Seedie
       end
     end
   end
-end
+end

data/lib/seedie/associations/has_one.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Seedie
   module Associations
     class HasOne < BaseAssociation
@@ -5,25 +7,23 @@ module Seedie
         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
+          raise InvalidAssociationConfigError, "has_one association cannot be more than 1" if count > 1
+
+          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/configuration.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Seedie
   class Configuration
     attr_accessor :default_count, :custom_attributes
@@ -6,5 +8,23 @@ module Seedie
       @default_count = nil
       @custom_attributes = {}
     end
+
+    # Prepares the custom_attributes hash for the specified models.
+    #
+    # This method ensures that the necessary keys exist in the custom_attributes hash.
+    # This prevents NoMethodError when setting model-specific custom attributes.
+    #
+    # Example usage:
+    # config.prepare_custom_attributes_for :user, :account
+    #
+    # Then this will work:
+    # config.custom_attributes[:user][:name] = "Name"
+    # config.custom_attributes[:account][:email] = "email@example.com"
+    #
+    def prepare_custom_attributes_for(*models)
+      models.inject(@custom_attributes) do |hash, key|
+        hash[key] ||= {}
+      end
+    end
   end
-end
+end

data/lib/seedie/field_values/custom_value.rb

@@ -1,9 +1,8 @@
+# frozen_string_literal: true
+
 module Seedie
   module FieldValues
     class CustomValue
-      VALID_KEYS = ["values", "value", "options"].freeze
-      PICK_STRATEGIES = ["random", "sequential"].freeze
-      
       attr_reader :name, :parsed_value
 
       def initialize(name, value_template, index)
@@ -12,7 +11,7 @@ module Seedie
         @index = index
         @parsed_value = ""
 
-        validate_value_template
+        ValueTemplateValidator.new(@value_template, @index, @name).validate
       end
 
       def generate_custom_field_value
@@ -27,89 +26,21 @@ module Seedie
 
       private
 
-      def validate_value_template
-        return unless @value_template.is_a?(Hash)
-
-        validate_keys
-        validate_values if @value_template.key?("values")
-        validate_options if @value_template.key?("options")
-      end
-
-      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_options
-        options = @value_template["options"]
-        pick_strategy = options["pick_strategy"]
-
-        if pick_strategy.present? && !PICK_STRATEGIES.include?(pick_strategy)
-          raise InvalidCustomFieldOptionsError,
-            "The pick_strategy for #{@name} must be either 'sequential' or 'random'."
-        end
-      end
-
-      ## If pick strategy is sequential, we need to ensure there is a value for each index
-      # If there isn't sufficient values, we raise an error
-      def validate_sequential_values_length
-        return unless @value_template.key?("options")
-        return unless @value_template["options"]["pick_strategy"] == "sequential"
-
-        values = @value_template["values"]
-
-        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
-
-        if values_length < @index + 1
-          raise CustomFieldNotEnoughValuesError,
-            "There are not enough values for #{@name}. Please add more values."
-        end
-      end
-
-      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
-
-          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
         @parsed_value = @value_template.gsub("{{index}}", @index.to_s)
 
         @parsed_value.gsub!(/\{\{(.+?)\}\}/) do
-          method_string = $1
+          method_string = ::Regexp.last_match(1)
 
-          if method_string.start_with?("Faker::")
-            eval($1)
-          else
-            raise InvalidFakerMethodError, "Invalid method: #{method_string}"
+          raise InvalidFakerMethodError, "Invalid method: #{method_string}" unless method_string.start_with?("Faker::")
+
+          method_chain = method_string.split(".")
+          # Faker::Name will be shifted off the array
+          faker_class = method_chain.shift.constantize
+
+          # For Faker::Internet.unique.email, there will be two methods in the array
+          method_chain.reduce(faker_class) do |current_class_or_value, method|
+            current_class_or_value.public_send(method)
           end
         end
       end
@@ -123,7 +54,7 @@ module Seedie
                       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

data/lib/seedie/field_values/fake_value.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Seedie
   module FieldValues
     class FakeValue
@@ -9,41 +11,107 @@ module Seedie
       def generate_fake_value
         case @column.type
         when :string, :text, :citext
-          Faker::Lorem.word
+          generate_string
         when :uuid
-          SecureRandom.uuid
+          generate_uuid
         when :integer, :bigint, :smallint
-          Faker::Number.number(digits: 5)
+          generate_integer
         when :decimal, :float, :real
-          Faker::Number.decimal(l_digits: 2, r_digits: 2)
+          generate_decimal
         when :datetime, :timestamp, :timestamptz
-          Faker::Time.between(from: DateTime.now - 1, to: DateTime.now)
+          generate_datetime
         when :date
-          Faker::Date.between(from: Date.today - 2, to: Date.today)
+          generate_date
         when :time, :timetz
-          Faker::Time.forward(days: 23, period: :morning)
+          generate_time
         when :boolean
-          Faker::Boolean.boolean
+          generate_boolean
         when :json, :jsonb
-          { "value" => { "key1" => Faker::Lorem.word, "key2" => Faker::Number.number(digits: 2) } }
+          generate_json
         when :inet
-          Faker::Internet.ip_v4_address
+          generate_inet
         when :cidr, :macaddr
-          Faker::Internet.mac_address
+          generate_macaddr
         when :bytea
-          Faker::Internet.password
+          generate_bytea
         when :bit, :bit_varying
-          ["0","1"].sample
+          generate_bit
         when :money
-          Faker::Commerce.price.to_s
+          generate_money
         when :hstore
-          { "value" => { "key1" => Faker::Lorem.word, "key2" => Faker::Number.number(digits: 2) } }
+          generate_hstore
         when :year
-          rand(1901..2155)
+          generate_year
         else
           raise UnknownColumnTypeError, "Unknown column type: #{@column.type}"
         end
       end
+
+      private
+
+      def generate_string
+        Faker::Lorem.word
+      end
+
+      def generate_uuid
+        SecureRandom.uuid
+      end
+
+      def generate_integer
+        Faker::Number.number(digits: 5)
+      end
+
+      def generate_decimal
+        Faker::Number.decimal(l_digits: 2, r_digits: 2)
+      end
+
+      def generate_datetime
+        Faker::Time.between(from: DateTime.now - 1, to: DateTime.now)
+      end
+
+      def generate_date
+        Faker::Date.between(from: Date.today - 2, to: Date.today)
+      end
+
+      def generate_time
+        Faker::Time.forward(days: 23, period: :morning)
+      end
+
+      def generate_boolean
+        Faker::Boolean.boolean
+      end
+
+      def generate_json
+        { "value" => { "key1" => Faker::Lorem.word, "key2" => Faker::Number.number(digits: 2) } }
+      end
+
+      def generate_inet
+        Faker::Internet.ip_v4_address
+      end
+
+      def generate_macaddr
+        Faker::Internet.mac_address
+      end
+
+      def generate_bytea
+        Faker::Internet.password
+      end
+
+      def generate_bit
+        %w[0 1].sample
+      end
+
+      def generate_money
+        Faker::Commerce.price.to_s
+      end
+
+      def generate_hstore
+        { "value" => { "key1" => Faker::Lorem.word, "key2" => Faker::Number.number(digits: 2) } }
+      end
+
+      def generate_year
+        rand(1901..2155)
+      end
     end
   end
-end
+end

data/lib/seedie/field_values/faker_builder.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Seedie
   module FieldValues
     class FakerBuilder
@@ -14,14 +16,15 @@ module Seedie
       end
 
       def build_faker_constant
-        return @seedie_config_custom_attributes[@name.to_sym] if @seedie_config_custom_attributes.key?(@name.to_sym)
+        custom_attribute = fetch_custom_attribute
+        return custom_attribute if fetch_custom_attribute
 
         @unique_prefix = "unique." if has_validation?(:uniqueness)
-        
+
         add_faker_class_and_method(@column.type)
-        
+
         if has_validation?(:inclusion)
-          handle_inclusion_validation 
+          handle_inclusion_validation
         else
           @options += handle_numericality_validation if has_validation?(:numericality)
           @options += handle_length_validation if has_validation?(:length)
@@ -37,61 +40,57 @@ module Seedie
 
       private
 
+      def fetch_custom_attribute
+        if @seedie_config_custom_attributes[@name.to_sym].is_a?(Hash)
+          return @seedie_config_custom_attributes.dig(@name.to_sym, @column.name.to_sym)
+        end
+
+        @seedie_config_custom_attributes[@name.to_sym]
+      end
+
       def add_faker_class_and_method(type)
         case type
         when :string, :text, :citext
-          @class_prefix = "Lorem."
-          @method_prefix = "word"
+          set_faker("Lorem.", "word")
         when :uuid
-          @class_prefix = "Internet."
-          @method_prefix = "uuid"
+          set_faker("Internet.", "uuid")
         when :integer, :bigint, :smallint
-          @class_prefix = "Number."
-          @method_prefix = "number"
-          @options = "(digits: 5)"
+          set_faker("Number.", "number", "(digits: 5)")
         when :decimal, :float, :real
-          @class_prefix = "Number."
-          @method_prefix = "decimal"
-          @options = "(l_digits: 2, r_digits: 2)"
+          set_faker("Number.", "decimal", "(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)"
+          set_faker("Time.", "between", "(from: DateTime.now - 1, to: DateTime.now)")
         when :date
-          @class_prefix = "Date."
-          @method_prefix = "between"
-          @options = "(from: Date.today - 1, to: Date.today)"
+          set_faker("Date.", "between", "(from: Date.today - 1, to: Date.today)")
         when :boolean
-          @class_prefix = "Boolean."
-          @method_prefix = "boolean"
+          set_faker("Boolean.", "boolean")
         when :json, :jsonb
           @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"
+          set_faker("Internet.", "ip_v4_address")
         when :cidr, :macaddr
-          @class_prefix = "Internet."
-          @method_prefix = "mac_address"
+          set_faker("Internet.", "mac_address")
         when :bytea
-          @class_prefix = "Internet."
-          @method_prefix = "password"
+          set_faker("Internet.", "password")
         when :bit, :bit_varying
-          @class_prefix = "Internet."
-          @method_prefix = "password"
+          set_faker("Internet.", "password")
         when :money
-          @class_prefix = "Commerce."
-          @method_prefix = "price.to_s"
+          set_faker("Commerce.", "price.to_s")
         when :hstore
           @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"
-          @options = "(digits: 4)"
+          set_faker("Number.", "number", "(digits: 4)")
         else
           raise UnknownColumnTypeError, "Unknown column type: #{type}"
         end
       end
 
+      def set_faker(class_prefix, method_prefix, options = "")
+        @class_prefix = class_prefix
+        @method_prefix = method_prefix
+        @options = options
+      end
+
       def has_validation?(kind)
         @validations.any? { |validation| validation.kind == kind }
       end
@@ -132,7 +131,8 @@ module Seedie
         @method_prefix = ""
         @options = ""
         if options[:in].is_a?(Range)
-          @faker_expression = { "values" => { "start" => options[:in].first, "end" => options[:in].last }, "options" => { "pick_strategy" => "random" } }
+          @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

data/lib/seedie/field_values/value_template_validator.rb

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

data/lib/seedie/field_values_set.rb

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