better_seeder 0.2.3.1 → 0.2.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d5b13470c3a8af2c331ef6254593d3268c5a82654802368c4af18608ad629185
-  data.tar.gz: ba63f74f95445e8b29bab7e33757c9ed460786a655fb9402733b0a7372436086
+  metadata.gz: 1d6d632652800d470d6214fa647d32b9fa48cab4c95ba88c7ff986a22093c33f
+  data.tar.gz: e9b16e216cd24c4f547f29f7f2fa50e690b5f31617145a84631f594186c60c6a
 SHA512:
-  metadata.gz: 8e215fd763c8348003cff4266ba1616eca6e3430e586c754b150ae2f68c97e969c23eec7ad946fd1ba7a1656feb3c507667ef45195834cd531546ea7ecba9e42
-  data.tar.gz: fc8b41742698a0cd0cf9b3db03a8b57bc2342b528bde096affe737a856f2a329b66063d5130b6b5a618caa1f8c87c169f60064ca4400575514ee1eca4e115feb
+  metadata.gz: 59358b3b0441b582abd6ec8601c97bc62e1e69b536b40e1f8137a3c1ba5b4495d66a862973da908d43ee5326c9aeebeab83cd594c665b42e10e42894380ee5a4
+  data.tar.gz: 3c99f4e4411e64ffb2626bd5016193792afd62122816e241f3f69f4825e8961c562850bd04eaf37e0fec90d03e26799c75a13ac24b4b4b45f168670ddc1b87e1

data/README.md

@@ -1,7 +1,22 @@
+![BetterSeeder Logo](logo.png)
 # BetterSeeder
 
 BetterSeeder is a Rails gem designed to simplify and centralize your application's seeding process. It offers a flexible system to generate dynamic data, validate it using Dry-schema, enforce uniqueness constraints, load data into the database, and export it in various formats (SQL, CSV, JSON). The configuration is managed through a Rails initializer, while model-specific logic is defined in dedicated structure files.
 
+## Statistics
+
+Below are two images displaying key statistics from the seeding process:
+
+- **Initial Generation Statistics:**  
+  This chart represents metrics from the very first generation run.
+
+![Initial Generation Statistics](generate.png)
+
+- **Reload Data Statistics:**  
+  This chart shows the metrics after reloading data (from the SQL file) into the database.
+
+![Reload Data Statistics](reload.png)
+
 ---
 
 ## Features
@@ -24,6 +39,12 @@ BetterSeeder is a Rails gem designed to simplify and centralize your application
 - **Rails Generator**  
   A custom Rails generator scaffolds a structure file template for your models, ensuring a consistent configuration format.
 
+- **Child Record Generation**  
+  Now, BetterSeeder supports generating multiple child records per parent record. In your model’s seed configuration, you can define a `childs` section that specifies the number of child records to generate for each parent, along with attribute arrays to assign distinct values for each child. This allows for a total record count equal to *(parent count) × (childs count)*.
+
+- **Preflight Data**  
+  You can now define a `preflight` method in your structure file. The records returned by this method are inserted first before generating any additional records, ensuring that specific data is loaded as part of the seeding process. The total record count (defined in `seed_config[:count]`) includes these preflight records.
+
 ---
 
 ## Installation
@@ -65,7 +86,7 @@ If these values are set in the initializer, they will be used; otherwise, the ge
 
 To streamline the setup, execute the following command in your Rails console:
 
-```ruby
+```bash
 BetterSeeder.install
 ```
 
@@ -85,12 +106,18 @@ For each model, create a structure file that centralizes the logic for generatin
 
 - **`seed_config`**  
   Returns a hash with model-specific seeding settings:
-  - `file_name`: The output file name (without extension)
-  - `columns: { excluded: [...] }`: Columns to exclude from the generated data
-  - `generate_data`: Boolean flag indicating whether to generate data dynamically (if false, existing records are used)
-  - `count`: The number of records to generate (default: 10)
-  - `load_data`: Boolean flag indicating whether the generated records should be inserted into the database
-  - `parent`: For child models, specifies the parent model(s) used for injecting foreign keys
+    - `file_name`: The output file name (without extension)
+    - `columns: { excluded: [...] }`: Columns to exclude from the generated data
+    - `generate_data`: Boolean flag indicating whether to generate data dynamically (if false, existing records are used)
+    - `count`: The number of parent records to generate (default: 10)
+    - `load_data`: Boolean flag indicating whether the generated records should be inserted into the database
+    - `parent`: For child models, specifies the parent model(s) used for injecting foreign keys
+    - **`childs` (Optional):** A hash to define child record generation:
+        - `count`: The number of child records to generate for each parent.
+        - `attributes`: A hash mapping attribute names to an array of values. Each child record will receive a distinct value from the provided array.
+      
+- **`preflight` (Optional)**  
+  If defined, this method should return an array of records to be inserted before generating dynamic records. These preloaded records count toward the total defined by `count`.
 
 - **`unique_keys` (Optional)**  
   Returns an array of column groups (each group is an array of symbols) that must be unique. For example:
@@ -132,10 +159,20 @@ module MyNamespace
         load_data: true,
         parents: [
           { model: ::MyNamespace::MyModelParent, column: :column_id }
-        ]
+        ],
+        childs: {
+          count: 3,
+          attributes: {
+            some_attribute: ['value1', 'value2', 'value3']
+          }
+        }
       }
     end
 
+    def self.preflight
+      [{ name: 'preloaded record', email: 'preloaded@example.com', created_at: Time.zone.now }]
+    end
+
     def self.unique_keys
       [[:email]]
     end
@@ -155,13 +192,16 @@ When you call `BetterSeeder.magic` with a configuration that contains an array o
 2. **Retrieve Seeding Configurations**  
    Invoke the model's `seed_config` method to obtain its specific settings.
 
-3. **Generate or Retrieve Records**  
+3. **Preflight Data**  
+   If a `preflight` method is defined in the structure file, its returned records will be inserted first. These records count toward the total number of records defined in `seed_config[:count]`.
+
+4. **Generate or Retrieve Records**  
    Use the `structure` method to generate data dynamically (or fetch existing records) and validate them using `seed_schema` if defined. Uniqueness is enforced via `unique_keys`.
 
-4. **Handle Parent/Child Relationships**  
-   Automatically inject foreign keys into child models using records from parent models.
+5. **Handle Parent/Child Relationships**  
+   Automatically inject foreign keys into child models using records from parent models. With the new functionality, if a `childs` configuration is present, the gem generates child records for each parent record. For example, if `count` is set to 200 and `childs[:count]` is set to 2, a total of 400 records will be generated. Each child record receives distinct attribute values from the specified arrays.
 
-5. **Load and Export Data**  
+6. **Load and Export Data**  
    If enabled (`load_data: true`), the generated records are inserted into the database and exported in the specified format (SQL, CSV, or JSON). Export files are saved in the directory specified by `BetterSeeder.configuration.preload_path`.
 
 ### Example Usage
@@ -257,6 +297,6 @@ BetterSeeder provides a modular, configurable, and extensible system for seeding
 
 - **Centralized Configuration:** Manage settings through a simple Rails initializer.
 - **Modular Structure Files:** Define data generation, validation, and configuration logic on a per-model basis.
-- **Seamless Data Handling:** Efficiently generate, validate, load, and export seed data while supporting complex relationships.
+- **Seamless Data Handling:** Efficiently generate, validate, load, and export seed data while supporting complex relationships—now with enhanced child record generation for a more realistic data model.
 
 For further details or to contribute, please refer to the official repository or documentation.

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,10 +14,8 @@ 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"
           structure_class_name = "#{model_name}Structure"
           begin
             structure_class = Object.const_get(structure_class_name)
@@ -28,67 +25,118 @@ module BetterSeeder
             raise error
           end
 
+          seed_config = structure_class.respond_to?(:seed_config) ? structure_class.seed_config : {}
+          total_count = seed_config[:count] || 10
+
           generated_records = []
 
-          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)
+          # Se il metodo preflight è definito, usalo per ottenere dati predefiniti
+          if structure_class.respond_to?(:preflight)
+            preflight_data = structure_class.preflight
+            generated_records.concat(preflight_data)
+          end
+
+          remaining_count = total_count - generated_records.size
+
+          if seed_config.key?(:childs)
+            # Modalità child: per ogni "record padre", generare childs_count record
+            childs_count = seed_config.dig(:childs, :count) || 10
+            # Calcolo: i record generati saranno i preflight + (remaining_count * childs_count)
+            remaining_count.times do |_i|
+              childs_count.times do |child_index|
+                new_record = nil
+                loop do
+                  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
+            # Modalità standard: genera remaining_count record
+            remaining_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 +145,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.5'
 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.5
 platform: ruby
 authors:
 - alessio_bussolari
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-02-12 00:00:00.000000000 Z
+date: 2025-03-04 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