seedie 0.2.0 → 0.4.0

data/lib/seedie/associations/base_association.rb

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

data/lib/seedie/associations/belongs_to.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Seedie
   module Associations
     class BelongsTo < BaseAssociation
@@ -11,7 +13,7 @@ module Seedie
 
       def generate_associations
         return if association_config["belongs_to"].nil?
-        
+
         report(:belongs_to_start)
 
         association_config["belongs_to"].each do |association_name, association_config|
@@ -29,7 +31,7 @@ module Seedie
 
       private
 
-      def handle_association_config_type(reflection, association_name, association_config)
+      def handle_association_config_type(reflection, _association_name, association_config)
         if reflection.polymorphic?
           handle_polymorphic_config_type(reflection, association_config)
         else
@@ -38,7 +40,6 @@ module Seedie
           handle_strategy(klass, reflection, strategy)
         end
       end
-      
 
       def handle_polymorphic_config_type(reflection, association_config)
         type_name = get_polymorphic_class_name(association_config["polymorphic"])
@@ -48,7 +49,7 @@ module Seedie
 
         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
@@ -89,27 +90,25 @@ module Seedie
 
       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(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)
         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
+        if association_config.is_a?(String) && !%w[random new unique].include?(association_config)
+          raise InvalidAssociationConfigError, "Invalid association config"
         end
+
+        association_config
       end
     end
   end
-end
+end

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

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+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,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
@@ -10,15 +12,18 @@ 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)
-        
+
         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,58 +42,46 @@ module Seedie
       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
@@ -129,7 +122,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