better_seeder 0.2.3.1 → 0.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d5b13470c3a8af2c331ef6254593d3268c5a82654802368c4af18608ad629185
-  data.tar.gz: ba63f74f95445e8b29bab7e33757c9ed460786a655fb9402733b0a7372436086
+  metadata.gz: 7efa6650656240adf416711cabab9debe997812e5e666472e3391c59ad74ce44
+  data.tar.gz: 504062b646d4800f75dbb20ef7e221fc0da730bf9aa207026795341e9e1c50e3
 SHA512:
-  metadata.gz: 8e215fd763c8348003cff4266ba1616eca6e3430e586c754b150ae2f68c97e969c23eec7ad946fd1ba7a1656feb3c507667ef45195834cd531546ea7ecba9e42
-  data.tar.gz: fc8b41742698a0cd0cf9b3db03a8b57bc2342b528bde096affe737a856f2a329b66063d5130b6b5a618caa1f8c87c169f60064ca4400575514ee1eca4e115feb
+  metadata.gz: bc24811f8a5ea605435701ee6ceda23927c1dad77327e054cd9b31756065037ef75a77f6b02bd1c2558f92870746de38366814bea90cd5597aba29a0b85b1e11
+  data.tar.gz: 34c2cfc41ca466c7c4e7e4db290a47fc0ffd92503b2fc65c567c716f7123138e2de4f2ce485f4b1c5dc1e56f40f3b8b205b4d96d51deec3da5d35ffc6bc124c0

data/lib/better_seeder/farms/farmer.rb

@@ -6,7 +6,6 @@ module BetterSeeder
       class << self
         def generate(options = {})
           model_name = options[:model] or raise ArgumentError, 'Missing :model option'
-          count      = options[:count] || 10
 
           # Costruisce il percorso del file di structure.
           structure_file = File.expand_path(
@@ -15,7 +14,6 @@ module BetterSeeder
           )
           raise "Structure file not found: #{structure_file}" unless File.exist?(structure_file)
 
-          # Carica il file di structure.
           load structure_file
 
           # Costruisce il nome della classe di structure: es. "Media::Participant" => "Media::ParticipantStructure"
@@ -28,67 +26,111 @@ module BetterSeeder
             raise error
           end
 
-          generated_records = []
+          seed_config = structure_class.respond_to?(:seed_config) ? structure_class.seed_config : {}
 
-          while generated_records.size < count
-            new_record = nil
-            loop do
-              new_record = build_record(model_name, structure_class)
-              new_record = inject_parent_keys(model_name, new_record, structure_class)
-              break if validate_record(new_record, structure_class) &&
-                       !record_exists?(model_name, new_record, structure_class, generated_records)
+          generated_records = []
+          if seed_config.key?(:childs)
+            # Logica per il modello child: il numero totale di record = count * childs_count
+            parent_count = seed_config[:count] || 10
+            childs_count = seed_config.dig(:childs, :count) || 10
+
+            parent_count.times do |_i|
+              childs_count.times do |child_index|
+                new_record = nil
+                loop do
+                  # Passo l'indice del record figlio per far variare gli attributi definiti in childs[:attributes]
+                  new_record = build_record(model_name, structure_class, child_index, child_mode: true)
+                  new_record = inject_parent_keys(model_name, new_record, structure_class)
+                  break if validate_record(new_record, structure_class) &&
+                    !record_exists?(model_name, new_record, structure_class, generated_records)
+                end
+                generated_records.push(new_record)
+              end
+            end
+          else
+            # Logica standard per i modelli parent (o modelli senza childs)
+            count = options[:count] || (seed_config[:count] || 10)
+            count.times do |index|
+              new_record = nil
+              loop do
+                new_record = build_record(model_name, structure_class, index)
+                new_record = inject_parent_keys(model_name, new_record, structure_class)
+                break if validate_record(new_record, structure_class) &&
+                  !record_exists?(model_name, new_record, structure_class, generated_records)
+              end
+              generated_records.push(new_record)
             end
-            generated_records.push(new_record)
           end
 
           generated_records
         end
 
+        # Il metodo build_record ora supporta la modalità child_mode.
+        # Se child_mode è true e nella configurazione (seed_config) è definita la chiave childs con :attributes,
+        # per ogni attributo viene usato il valore dell'array corrispondente all'indice (child_index) passato.
+        def build_record(_model_name, structure_class, index, child_mode: false)
+          generation_rules = structure_class.structure
+          raise 'Structure must be a Hash' unless generation_rules.is_a?(Hash)
+
+          seed_config = structure_class.respond_to?(:seed_config) ? structure_class.seed_config : {}
+
+          record = {}
+          generation_rules.each do |attribute, rule|
+            generator = rule[1]
+            if child_mode && seed_config.dig(:childs, :attributes, attribute).is_a?(Array)
+              values = seed_config[:childs][:attributes][attribute]
+              value  = values[index] # index viene passato dal loop interno
+            else
+              value = generator.respond_to?(:call) ? generator.call : generator
+            end
+            record[attribute] = value
+          end
+
+          record
+        end
+
+        # Restituisce il numero di record figli da generare per ciascun "record padre".
+        # Nel caso in cui nella configurazione sia presente la chiave childs, restituisce childs[:count],
+        # altrimenti default a 10.
+        def child_record_count(options = {})
+          model_name = options[:model] or raise ArgumentError, 'Missing :model option'
+
+          structure_file = File.expand_path(
+            File.join(BetterSeeder.configuration.structure_path, "#{model_name.underscore}_structure.rb"),
+            Dir.pwd
+          )
+          raise "Structure file not found: #{structure_file}" unless File.exist?(structure_file)
+
+          load structure_file
+          structure_class_name = "#{model_name}Structure"
+          structure_class = Object.const_get(structure_class_name)
+          seed_config = structure_class.respond_to?(:seed_config) ? structure_class.seed_config : {}
+          seed_config.dig(:childs, :count) || 10
+        end
+
         private
 
         def record_exists?(_model_name, record, structure_class, generated_records)
-          # Se non è definito il metodo unique_keys, non eseguiamo il controllo
           return false unless structure_class.respond_to?(:unique_keys)
 
           unique_key_sets = structure_class.unique_keys
           return false if unique_key_sets.empty?
 
-          # Determina il modello associato: si assume che il nome del modello sia
-          # dato dalla rimozione della stringa "Structure" dal nome della classe di structure.
           model_class_name = structure_class.to_s.sub(/Structure$/, '')
           model_class      = Object.const_get(model_class_name)
 
-          # Per ogni set di chiavi uniche, costruiamo le condizioni della query
           unique_key_sets.each do |key_set|
             conditions = {}
             key_set.each do |col|
               conditions[col] = record[col]
             end
-            # Se esiste un record nel database che soddisfa le condizioni, restituisce true.
-            return true if generated_records.find do |record|
-              conditions.all? { |key, value| record[key] == value }
-            end.present?
+            return true if generated_records.find { |r| conditions.all? { |key, value| r[key] == value } }
             return true if model_class.where(conditions).exists?
           end
 
           false
         end
 
-        def build_record(_model_name, structure_class)
-          generation_rules = structure_class.structure
-          raise 'Structure must be a Hash' unless generation_rules.is_a?(Hash)
-
-          record = {}
-          generation_rules.each do |attribute, rule|
-            # Ogni rule è un array nel formato [tipo, generatore]
-            generator         = rule[1]
-            value             = generator.respond_to?(:call) ? generator.call : generator
-            record[attribute] = value
-          end
-
-          record
-        end
-
         def inject_parent_keys(_model_name, record, structure_class)
           config       = structure_class.respond_to?(:seed_config) ? structure_class.seed_config : {}
           parents_spec = config[:parents]
@@ -97,21 +139,17 @@ module BetterSeeder
           parents_spec.each do |parent_config|
             parent_model = parent_config[:model]
             column       = parent_config[:column]
+            pool_key     = parent_model.to_s
 
-            # Tenta di ottenere un record del parent dal pool BetterSeeder.generated_records se disponibile.
-            # Usiamo il nome del modello come chiave nel pool.
-            pool_key      = parent_model.to_s
             unless defined?(BetterSeeder.generated_records) &&
-                   BetterSeeder.generated_records[pool_key] &&
-                   !BetterSeeder.generated_records[pool_key].empty?
+              BetterSeeder.generated_records[pool_key] &&
+              !BetterSeeder.generated_records[pool_key].empty?
               BetterSeeder.generated_records[pool_key] = parent_model.all
             end
-            parent_record = BetterSeeder.generated_records[pool_key].sample
 
+            parent_record = BetterSeeder.generated_records[pool_key].sample
             raise "Parent record not found for #{parent_model}" unless parent_record
 
-            # Inietta nel record la chiave esterna indicata nella configurazione.
-            # binding.pry if model_name == "Media::Participant"
             record[column] = parent_record[:id]
           end
 

data/lib/better_seeder/utils/common.rb

@@ -0,0 +1,69 @@
+module BetterSeeder
+  module Utils
+    module Common
+      class << self
+
+        ##
+        # Trasforma un nome di classe in snake_case e aggiunge il suffisso "_structure.rb".
+        #
+        # ==== Esempio
+        #   transform_class_name("Campaigns::Campaign")
+        #   # => "campaigns/campaign_structure.rb"
+        #
+        # ==== Parametri
+        # * +class_name+ - Stringa che rappresenta il nome della classe, eventualmente suddiviso in
+        #   namespace separati da "::".
+        #
+        # ==== Ritorno
+        # Restituisce una stringa con il nome della classe in formato snake_case e l'ultimo elemento
+        # terminato con "_structure.rb".
+        #
+        def transform_class_name(class_name)
+          elements = class_name.split('::').map(&:underscore)
+          # Aggiunge "_structure.rb" all'ultimo elemento
+          elements[-1] = "#{elements[-1]}_structure.rb"
+          elements.join('/')
+        end
+
+        ##
+        # Registra un messaggio usando il logger di Rails se disponibile, altrimenti lo stampa su standard output.
+        #
+        # ==== Parametri
+        # * +message+ - Il messaggio da loggare (può essere una stringa o nil).
+        #
+        # ==== Ritorno
+        # Non ritorna un valore significativo.
+        #
+        def logger(message: nil)
+          if defined?(Rails) && Rails.respond_to?(:logger) && Rails.logger
+            Rails.logger.info message
+          else
+            puts message
+          end
+        end
+
+        ##
+        # Configura il livello del logger per ActiveRecord in base alla configurazione definita in BetterSeeder.
+        #
+        # ==== Dettagli
+        # Il metodo imposta il livello del logger in base al valore di BetterSeeder.configuration.log_level:
+        # * +:debug+ -> Logger::DEBUG
+        # * +:info+  -> Logger::INFO
+        # * +:error+ -> Logger::ERROR
+        # Se il livello non corrisponde a nessuna delle opzioni previste, viene impostato il livello +Logger::DEBUG+.
+        #
+        def log_level_setup
+          level = case BetterSeeder.configuration.log_level
+                  when :debug then Logger::DEBUG
+                  when :info then Logger::INFO
+                  when :error then Logger::ERROR
+                  else Logger::DEBUG
+                  end
+
+          ActiveRecord::Base.logger.level = level
+        end
+
+      end
+    end
+  end
+end

data/lib/better_seeder/utils/store.rb

@@ -0,0 +1,36 @@
+# Questo file definisce il modulo +BetterSeeder::Utils::Store+ che offre
+# metodi per memorizzare e recuperare record generati e per gestire la configurazione globale.
+#
+module BetterSeeder
+  module Utils
+    module Store
+      class << self
+
+        @generated_records = {}
+
+        ##
+        # Restituisce l'hash contenente i record generati.
+        #
+        # @return [Hash] hash con i record generati per ciascun modello.
+        #
+        def generated_records
+          @generated_records
+        end
+
+        ##
+        # Memorizza un record generato per il modello specificato.
+        #
+        # Se non esiste già, viene inizializzato un array vuoto per il modello.
+        #
+        # @param model_name [String, Symbol] il nome del modello
+        # @param record [Object] il record da memorizzare
+        #
+        def store_generated_record(model_name, record)
+          @generated_records[model_name.to_s] ||= []
+          @generated_records[model_name.to_s] << record
+        end
+
+      end
+    end
+  end
+end

data/lib/better_seeder/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module BetterSeeder
-  VERSION = '0.2.3.1'
+  VERSION = '0.2.4'
 end

data/lib/better_seeder.rb

@@ -11,22 +11,6 @@ require_relative 'better_seeder/exporters/sql'
 require_relative 'better_seeder/builders/structure'
 
 module BetterSeeder
-  class Configuration
-    attr_accessor :log_language, :structure_path, :preload_path
-
-    def initialize
-      @log_language   = :en
-      @log_level      = :info
-      if defined?(Rails) && Rails.respond_to?(:root)
-        @structure_path = Rails.root.join('db', 'seed', 'structure')
-        @preload_path   = Rails.root.join('db', 'seed', 'preload')
-      else
-        @structure_path = File.join(Dir.pwd, 'db', 'seed', 'structure')
-        @preload_path   = File.join(Dir.pwd, 'db', 'seed', 'preload')
-      end
-    end
-  end
-
   # Definisce un hash che fungerà da pool per memorizzare i record generati per ciascun modello.
   @generated_records = {}
 
@@ -189,14 +173,13 @@ module BetterSeeder
 
     # Recupera la classe reale del modello (ActiveRecord).
     model_class = begin
-      Object.const_get(model_name)
-    rescue StandardError
-      nil
-    end
+                    Object.const_get(model_name)
+                  rescue StandardError
+                    nil
+                  end
     unless model_class
       message = "[ERROR] Model #{model_name} not found."
       BetterSeeder::Utils.logger(message: message)
-
       raise Object.const_get(model_name)
     end
 
@@ -208,8 +191,7 @@ module BetterSeeder
       records                           = Farms::Farmer.generate(model: model_name, count: count)
       total_records                     = records.size
       stats[model_name]                 = total_records
-      created_records                   = load_records_into_db(model_class, records, total_records, model_name,
-                                                               superclass)
+      created_records                   = load_records_into_db(model_class, records, total_records, model_name, superclass)
       # Se il modello è parent, salva i record creati per poterli utilizzare in seguito per i modelli child.
       parent_loaded_records[model_name] = created_records if parent.nil?
     else
@@ -220,8 +202,8 @@ module BetterSeeder
     return if BetterSeeder.generated_records[(superclass || model_name).to_s].nil?
 
     processed_records = BetterSeeder.generated_records[(superclass || model_name).to_s]
-    processed_records = processed_records.map do |campaign|
-      campaign.attributes.except(*excluded_columns.map(&:to_s))
+    processed_records = processed_records.map do |record|
+      record.attributes.except(*excluded_columns.map(&:to_s))
     end
 
     # Esporta i record nel formato richiesto.

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: better_seeder
 version: !ruby/object:Gem::Version
-  version: 0.2.3.1
+  version: 0.2.4
 platform: ruby
 authors:
 - alessio_bussolari
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-02-12 00:00:00.000000000 Z
+date: 2025-03-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dry-schema
@@ -142,6 +142,8 @@ files:
 - lib/better_seeder/farms/farmer.rb
 - lib/better_seeder/structure/utils.rb
 - lib/better_seeder/utils.rb
+- lib/better_seeder/utils/common.rb
+- lib/better_seeder/utils/store.rb
 - lib/better_seeder/version.rb
 - lib/generators/better_seeder/structure_generator.rb
 homepage: https://github.com/alessiobussolari/better_seeder