better_seeder 0.2.2 → 0.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 19461c43288bc59e79dcad650e0f64ab6b135db335813fb29ae9ddacbed238d3
-  data.tar.gz: db98585d74a4f04644ab60ec254d469e12f7078e157ec505a0c4d8b909850aad
+  metadata.gz: 20203d64e75c796bd405cb5caaabeb697ee4cd64b2a21770cc2703efaaedf815
+  data.tar.gz: 8b218cd82cc8950284fa4fe0468443481760e092161c9a96f9ea2b0ae9974c28
 SHA512:
-  metadata.gz: 5b0dc886f98b74bdd3e72ff07b52c72786b74f8c21937204c6e04a5dfcbb94c883b0d27bc1a83c18ea00c0adf99d766fde94a17cb6390c1369b5773e3b903666
-  data.tar.gz: b4dd522996c4ac5a6113f82ef99010e104c988afa815c8476c6040dea4c65f738646d0c4d617600a22344c8c2031c57825903d7d2c897b1ccfd95c226a2fd9a5
+  metadata.gz: f193936be5c4bb4416bc27b2cdbb869c10c8dbe4a8d3046d63cc0ffd1af4e31edd7e0e613ab1828913df5a64fd225523211a158662b783491022a2109233ccb4
+  data.tar.gz: 806324afb167aa6376f8c5dbf5fbe13083f4bcc9ec1e89c8bcbb46b021f5c29b27318580b63e2dacc42d4bfb3bf54d22afde05142acecd6a49aee82a23c561ae

data/README.md

@@ -1,6 +1,6 @@
 # BetterSeeder
 
-**BetterSeeder** is a Rails gem designed to simplify and centralize your application's seeding process. It provides a flexible system to generate dynamic data, validate it using Dry-schema, enforce uniqueness constraints, load it into the database, and export it in various formats (SQL, CSV, JSON). Configuration is centralized via a Rails initializer, while model-specific logic is defined in dedicated structure files.
+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.
 
 ---
 
@@ -10,17 +10,19 @@
   Define custom data generators for each model in dedicated structure files.
 
 - **Validation and Uniqueness**  
-  Validate generated records using Dry-schema and enforce uniqueness constraints (both single and multi-column).
+  Validate generated records using Dry-schema and enforce uniqueness constraints across one or multiple columns.
 
 - **Loading & Exporting**  
-  - Load generated data directly into your database (with support for parent/child relationships).  
-  - Export data as a single SQL INSERT statement, or in CSV or JSON formats.
+  Load generated data directly into your database—supporting parent/child relationships—and export the data as a single SQL INSERT statement, CSV, or JSON file.
 
 - **Centralized Configuration**  
-  Easily customize settings such as `log_language`, `structure_path`, and `preload_path` via a Rails initializer. If no initializer is provided, default values are used.
+  Customize settings such as `log_language`, `structure_path`, and `preload_path` via a Rails initializer. If no initializer is provided, default settings apply.
 
-- **Automatic Initializer Installation**  
-  Use the `BetterSeeder.install` method to automatically create the initializer file in your Rails app.
+- **Initializer Installation**  
+  An install method creates the necessary initializer file in your Rails application to streamline setup.
+
+- **Rails Generator**  
+  A custom Rails generator scaffolds a structure file template for your models, ensuring a consistent configuration format.
 
 ---
 
@@ -42,7 +44,7 @@ bundle install
 
 ## Configuration
 
-BetterSeeder uses a centralized configuration defined in `BetterSeeder.configuration`. You can override the default settings via an initializer. For example, create a file:
+BetterSeeder uses a centralized configuration defined in `BetterSeeder.configuration`. You can override the default settings by creating an initializer. For example, create a file:
 
 ```ruby
 # config/initializers/better_seeder.rb
@@ -55,53 +57,43 @@ BetterSeeder.configure do |config|
 end
 ```
 
-If these values are set in the initializer, they will be used; otherwise, the gem will fall back to its default values.
+If these values are set in the initializer, they will be used; otherwise, the gem will use its default values.
 
 ---
 
-## Install Method
+## Initializer Installation
 
-BetterSeeder provides an `install` method that automatically creates an initializer file. To run the installer, simply execute in your Rails console:
+To streamline the setup, execute the following command in your Rails console:
 
 ```ruby
 BetterSeeder.install
 ```
 
-This command creates (if not already present) the file `config/initializers/better_seeder.rb` with content similar to:
-
-```ruby
-# BetterSeeder initializer
-BetterSeeder.configure do |config|
-  config.log_language   = :en
-  config.structure_path = Rails.root.join('db', 'seed', 'structure')
-  config.preload_path   = Rails.root.join('db', 'seed', 'preload')
-end
-```
+This command creates (if not already present) the file `config/initializers/better_seeder.rb` with the necessary configuration.
 
 ---
 
 ## Structure Files
 
-For each model, create a structure file that centralizes the logic for generating, validating, and configuring seed data. Each structure file should define at least the following methods:
+For each model, create a structure file that centralizes the logic for generating, validating, and configuring seed data. Each structure file should include:
 
 - **`structure`**  
-  Returns a hash where each key represents an attribute and its value is an array in the format `[type, lambda_generator]`.
+  Returns a hash where each key is an attribute and its value is an array in the format `[type, lambda_generator]`.
 
 - **`seed_schema` (Optional)**  
-  Defines a Dry-schema for validating the generated records.
+  Defines a Dry-schema for validating generated records.
 
 - **`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, this 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 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
 
 - **`unique_keys` (Optional)**  
-  Returns an array of column groups (each group is an array of symbols) that must be unique.  
-  For example:
+  Returns an array of column groups (each group is an array of symbols) that must be unique. For example:
 
   ```ruby
   def self.unique_keys
@@ -111,13 +103,10 @@ For each model, create a structure file that centralizes the logic for generatin
 
 ### Example Structure File
 
-For a generic model `MyModel` in the namespace `MyNamespace`, create a file at `db/seed/structure/my_namespace/my_model_structure.rb`:
-
 ```ruby
 # db/seed/structure/my_namespace/my_model_structure.rb
 module MyNamespace
   class MyModelStructure < BetterSeeder::StructureBase
-    # Defines generators for each attribute.
     def self.structure
       {
         name:       [:string,   -> { FFaker::Name.name }],
@@ -126,7 +115,6 @@ module MyNamespace
       }
     end
 
-    # Optional: Validate generated records using Dry-schema.
     def self.seed_schema
       Dry::Schema.Params do
         required(:name).filled(:string)
@@ -135,7 +123,6 @@ module MyNamespace
       end
     end
 
-    # Specific seeding configuration for MyModel.
     def self.seed_config
       {
         file_name: 'my_model_seed',
@@ -147,7 +134,6 @@ module MyNamespace
       }
     end
 
-    # Optional: Uniqueness constraints; for example, email must be unique.
     def self.unique_keys
       [[:email]]
     end
@@ -162,19 +148,19 @@ end
 When you call `BetterSeeder.magic` with a configuration that contains an array of model names (as strings), the gem will:
 
 1. **Load Structure Files**  
-   For each model, the gem loads the corresponding structure file from `BetterSeeder.configuration.structure_path`.
+   Retrieve the corresponding structure file from the directory defined by `BetterSeeder.configuration.structure_path` for each model.
 
 2. **Retrieve Seeding Configurations**  
-   It calls the model's `seed_config` method to get its specific settings.
+   Invoke the model's `seed_config` method to obtain its specific settings.
 
 3. **Generate or Retrieve Records**  
-   Using the `structure` method, the gem generates data dynamically (or retrieves existing records) and validates them with `seed_schema` if provided. Uniqueness is enforced based on `unique_keys`.
+   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**  
-   For child models, foreign keys are automatically injected using the records from the parent models.
+   Automatically inject foreign keys into child models using records from parent models.
 
-5. **Load and Export**  
-   If enabled (`load_data: true`), the generated records are inserted into the database and then exported in the specified format (SQL, CSV, or JSON). Export files are saved in the directory defined by `BetterSeeder.configuration.preload_path` (default: `db/seed/preload`).
+5. **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
 
@@ -190,24 +176,17 @@ BetterSeeder.magic(
 )
 ```
 
-This command processes each model by:
-
-- Reading its structure file and retrieving its configuration via `seed_config`.
-- Generating or fetching data according to the specified rules.
-- Inserting the data into the database (if `load_data` is enabled).
-- Exporting the data as an SQL file (or CSV/JSON, depending on `export_type`).
-
 ---
 
-## Structure Generator
+## Rails Generator
 
-BetterSeeder now provides a custom Rails generator to scaffold a structure file template for your models. You can generate a structure file automatically using the following command:
+A custom Rails generator is available to scaffold a structure file template for your models. Execute the following command:
 
 ```bash
 rails generate better_seeder:structure MyNamespace::MyModel
 ```
 
-This command creates a structure file template in the appropriate subdirectory under `db/seed/structure`. The generated file includes placeholders for:
+This command creates a structure file template in the appropriate subdirectory under `db/seed/structure`. The generated template includes placeholders for:
 
 - Attribute generators (via the `structure` method)
 - Validation schema (via the `seed_schema` method)
@@ -219,21 +198,18 @@ This command creates a structure file template in the appropriate subdirectory u
 ```ruby
 module MyNamespace
   class MyModelStructure < BetterSeeder::StructureBase
-    # Defines generators for each attribute.
     def self.structure
       {
         attribute_name: [:string, -> { "your value" }]
       }
     end
 
-    # Optional: Validate generated records using Dry-schema.
     def self.seed_schema
       Dry::Schema.Params do
         required(:attribute_name).filled(:string)
       end
     end
 
-    # Specific seeding configuration for MyModel.
     def self.seed_config
       {
         file_name: 'my_model_seed',
@@ -245,7 +221,6 @@ module MyNamespace
       }
     end
 
-    # Optional: Uniqueness constraints.
     def self.unique_keys
       []
     end
@@ -253,27 +228,33 @@ module MyNamespace
 end
 ```
 
-This generator streamlines the setup of new structure files, ensuring consistency and saving time when defining your seed data configuration.
+This generator ensures a consistent structure for your seeding configuration across models.
 
-### Benefits
+---
 
-- **Automated Scaffolding:** Quickly generate a complete structure file template for any model.
-- **Consistency:** All generated files adhere to a standard format, ensuring consistency across your seeding logic.
-- **Customization:** Easily modify the generated file to fine-tune attribute generators, validation rules, seeding configuration, and uniqueness constraints.
+## Contact & Feature Requests
+
+For suggestions, bug reports, or to report new feature requests, please reach out via email at: **alessio.bussolari@pandev.it**.
 
 ---
 
-## Conclusion
+## Upcoming Features
 
-BetterSeeder provides a modular, configurable, and extensible system for seeding your Rails application's data:
+The development team is continuously enhancing BetterSeeder. Current efforts include:
 
-- **Centralized Configuration:**  
-  Configure paths and logging via a Rails initializer.
+- **Additional Export Formats:** Expanding beyond SQL, CSV, and JSON to offer more options.
+- **Enhanced Rails Associations Integration:** Improving support for complex parent/child relationships.
+- **Expanded Configuration Options:** Providing more granular control over the seeding process.
+- **Performance Optimizations:** Refining data generation algorithms for faster processing.
+
+---
+
+## Conclusion
 
-- **Modular Structure Files:**  
-  Define generation, validation, and configuration logic for each model in dedicated structure files.
+BetterSeeder provides a modular, configurable, and extensible system for seeding your Rails application's data. Its key benefits include:
 
-- **Seamless Data Handling:**  
-  Automatically generate, validate, load, and export seed data with support for parent/child relationships and various export formats.
+- **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.
 
-For further details or contributions, please refer to the official repository or documentation.
+For further details or to contribute, please refer to the official repository or documentation.

data/lib/better_seeder/configuration.rb

@@ -2,15 +2,17 @@
 
 module BetterSeeder
   class Configuration
-    attr_accessor :log_language, :structure_path, :preload_path
+    attr_accessor :log_language, :log_level, :structure_path, :preload_path
 
     def initialize
       if defined?(Rails) && Rails.respond_to?(:root)
         @log_language   = :en
+        @log_level   = :info
         @structure_path = Rails.root.join('db', 'seed', 'structure')
         @preload_path   = Rails.root.join('db', 'seed', 'preload')
       else
         @log_language   = :en
+        @log_level   = :info
         @structure_path = File.join(Dir.pwd, 'db', 'seed', 'structure')
         @preload_path   = File.join(Dir.pwd, 'db', 'seed', 'preload')
       end

data/lib/better_seeder/farms/farmer.rb

@@ -1,116 +1,133 @@
 module BetterSeeder
   module Farms
     class Farmer
-      # Genera dati fittizi per il modello specificato utilizzando il file di structure.
-      #
-      # Opzioni attese (Hash):
-      #   :model => Nome del modello come stringa, es. 'Media::Participant'
-      #   :count => Numero di record da generare (default: 10)
-      #
-      # Se la classe di structure definisce il metodo `unique_keys` (che deve restituire un array di array,
-      # es. [[:media_id, :creator_id], [:role]]), verrà controllato che ogni record generato sia univoco,
-      # sia in memoria (tra quelli generati in questa esecuzione) che rispetto ai dati già presenti nel database.
-      # Se il record è duplicato, verrà rigenerato.
-      #
-      # Se la classe di structure definisce il metodo `seed_schema`, il record verrà validato tramite Dry-schema.
-      #
-      # @return [Array<Hash>] Array di record validati e univoci generati
-      def self.generate(options = {})
-        model_name = options[:model] or raise ArgumentError, "Missing :model option"
-        count      = options[:count]  || 10
-
-        # Costruisce il percorso del file di structure.
-        # Ad esempio, per il modello "Media::Participant", il file atteso sarà:
-        # "db/seed/structure/media/participant_structure.rb"
-        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)
-
-        # Carica il file di structure.
-        load structure_file
-
-        # Costruisce il nome della classe di structure: semplice concatenazione.
-        # Es: "Media::Participant" => "Media::ParticipantStructure"
-        structure_class_name = "#{model_name}Structure"
-        begin
-          structure_class = Object.const_get(structure_class_name)
-        rescue error
-          message = "Structure class not found: #{structure_class_name}"
-          BetterSeeder::Utils.logger(message: message)
-          raise error
+
+      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(
+            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)
+
+          # 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)
+          rescue error
+            message = "Structure class not found: #{structure_class_name}"
+            BetterSeeder::Utils.logger(message: message)
+            raise error
+          end
+
+          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)
+            end
+            generated_records.push(new_record)
+          end
+
+          generated_records
         end
 
-        generation_rules = structure_class.structure
-        raise "Structure must be a Hash" unless generation_rules.is_a?(Hash)
-
-        # Recupera lo schema per la validazione, se definito.
-        schema = structure_class.respond_to?(:seed_schema) ? structure_class.seed_schema : nil
-
-        # Gestione dei vincoli di unicità.
-        # Se il metodo unique_keys è definito, lo si aspetta come array di array,
-        # ad esempio: [[:media_id, :creator_id], [:role]]
-        unique_key_sets = structure_class.respond_to?(:unique_keys) ? structure_class.unique_keys : []
-        # Pre-carica i valori già presenti nel database per ciascun gruppo di colonne.
-        unique_sets = unique_key_sets.map do |cols|
-          existing_keys = Set.new
-          # Usa pluck per recuperare le colonne specificate dal modello.
-          # Se il gruppo è di una sola colonna, pluck restituirà un array di valori; se multi, un array di array.
-          db_rows = Object.const_get(model_name).pluck(*cols)
-          db_rows.each do |row|
-            composite_key = cols.size == 1 ? row.to_s : row.join("_")
-            existing_keys.add(composite_key)
+        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 model_class.where(conditions).exists?
           end
-          { columns: cols, set: existing_keys }
+
+          false
         end
 
-        generated_records = []
-        progressbar = ProgressBar.create(total: count, format: '%a %B %p%% %t')
-        attempts = 0
+        def build_record(model_name, structure_class)
+          generation_rules = structure_class.structure
+          raise "Structure must be a Hash" unless generation_rules.is_a?(Hash)
 
-        # Continua a generare record finché non si raggiunge il numero richiesto.
-        while generated_records.size < count
-          attempts += 1
           record = {}
           generation_rules.each do |attribute, rule|
-            # Ogni rule è un array: [tipo, generatore]
+            # Ogni rule è un array nel formato [tipo, generatore]
             generator = rule[1]
             value = generator.respond_to?(:call) ? generator.call : generator
             record[attribute] = value
           end
 
-          # Se è definito uno schema, valida il record.
-          if schema
-            result = schema.call(record)
-            unless result.success?
-              message = "[ERROR] Record validation failed for #{model_name}: #{result.errors.to_h}"
-              BetterSeeder::Utils.logger(message: message)
-              progressbar.increment
-              next  # Rigenera il record se la validazione fallisce.
-            end
-          end
+          record
+        end
 
-          # Controlla i vincoli di unicità: verifica che il record non sia già presente
-          duplicate = unique_sets.any? do |unique_set|
-            composite_key = unique_set[:columns].map { |col| record[col].to_s }.join("_")
-            unique_set[:set].include?(composite_key)
-          end
-          next if duplicate
+        def inject_parent_keys(model_name, record, structure_class)
+          config = structure_class.respond_to?(:seed_config) ? structure_class.seed_config : {}
+          parents_spec = config[:parents]
+          return record unless parents_spec && !parents_spec.empty?
+
+          parents_spec.each do |parent_config|
+            parent_model = parent_config[:model]
+            column = parent_config[:column]
 
-          # Aggiorna le strutture per il controllo di unicità con il nuovo record.
-          unique_sets.each do |unique_set|
-            composite_key = unique_set[:columns].map { |col| record[col].to_s }.join("_")
-            unique_set[:set].add(composite_key)
+            # 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
+            parent_record = if defined?(BetterSeeder.generated_records) &&
+              BetterSeeder.generated_records[pool_key] &&
+              !BetterSeeder.generated_records[pool_key].empty?
+                              BetterSeeder.generated_records[pool_key].sample
+                            else
+                              BetterSeeder.generated_records[pool_key] = parent_model.all
+                              BetterSeeder.generated_records[pool_key].sample
+                            end
+
+            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
 
-          generated_records << record
-          progressbar.increment
+          record
+        end
+
+        def validate_record(record, structure_class)
+          return true unless structure_class.respond_to?(:seed_schema_validation)
+
+          schema = structure_class.seed_schema_validation
+          result = schema.call(record)
+          return true if result.success?
+
+          raise result.errors.to_h
         end
 
-        message = "[INFO] Generated #{generated_records.size} unique records for #{model_name} after #{attempts} attempts."
-        BetterSeeder::Utils.logger(message: message)
-        generated_records
       end
     end
   end

data/lib/better_seeder/utils.rb

@@ -2,21 +2,36 @@
 
 module BetterSeeder
   module Utils
-    # Trasforma un nome di classe in snake_case.
-    # Esempio: "Campaigns::Campaign" => "campaigns_campaign"
-    def self.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
 
-    def self.logger(message: nil)
-      if defined?(Rails) && Rails.respond_to?(:logger) && Rails.logger
-        Rails.logger.info message
-      else
-        puts message
+    class << self
+      # Trasforma un nome di classe in snake_case.
+      # Esempio: "Campaigns::Campaign" => "campaigns_campaign"
+      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
+
+      def logger(message: nil)
+        if defined?(Rails) && Rails.respond_to?(:logger) && Rails.logger
+          Rails.logger.info message
+        else
+          puts message
+        end
       end
+
+      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

data/lib/better_seeder/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module BetterSeeder
-  VERSION = "0.2.2"
+  VERSION = "0.2.3"
 end

data/lib/better_seeder.rb

@@ -14,17 +14,31 @@ module BetterSeeder
 
     def initialize
       if defined?(Rails) && Rails.respond_to?(:root)
-        @log_language   = :en
+        @log_language = :en
+        @log_level = :info
         @structure_path = Rails.root.join('db', 'seed', 'structure')
-        @preload_path   = Rails.root.join('db', 'seed', 'preload')
+        @preload_path = Rails.root.join('db', 'seed', 'preload')
       else
-        @log_language   = :en
+        @log_language = :en
+        @log_level = :info
         @structure_path = File.join(Dir.pwd, 'db', 'seed', 'structure')
-        @preload_path   = File.join(Dir.pwd, 'db', 'seed', 'preload')
+        @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 = {}
+
+  def self.generated_records
+    @generated_records
+  end
+
+  def self.store_generated_record(model_name, record)
+    @generated_records[model_name.to_s] ||= []
+    @generated_records[model_name.to_s] << record
+  end
+
   # Restituisce l'istanza globale di configurazione. Se non esiste, viene creata con i valori di default.
   def self.configuration
     @configuration ||= Configuration.new
@@ -47,6 +61,7 @@ module BetterSeeder
   # Metodo install che crea l'initializer di BetterSeeder in config/initializers
   # con le seguenti impostazioni:
   #   - log_language: lingua da usare per i log (es. :en, :it)
+  #   - log_level: livello di logging nell'output dei dati del seeder (:debug, :info, :error)
   #   - structure_path: percorso dove sono memorizzati i file di structure (default: Rails.root/db/seed/structure)
   #   - preload_path: percorso dove verranno salvati i file esportati (default: Rails.root/db/seed/preload)
   def self.install
@@ -60,6 +75,7 @@ module BetterSeeder
         # This file was generated by BetterSeeder.install
         BetterSeeder.configure do |config|
           config.log_language = :en
+          config.log_level = :error
           config.structure_path = Rails.root.join('db', 'seed', 'structure')
           config.preload_path = Rails.root.join('db', 'seed', 'preload')
         end
@@ -94,9 +110,15 @@ module BetterSeeder
   #   - Se abilitato, i record vengono caricati nel database e successivamente esportati nel formato richiesto
   #   - Vengono raccolte statistiche e loggato il tempo totale di esecuzione
   def self.magic(config)
+    previous_log_level = ActiveRecord::Base.logger.level
+    BetterSeeder::Utils.log_level_setup
+
+    message = "[LOGGER] previous log level: #{previous_log_level}, actual log level: #{ActiveRecord::Base.logger.level}"
+    BetterSeeder::Utils.logger(message: message)
+
     start_time = Time.now
-    stats = {}                   # Statistiche: modello => numero di record caricati
-    parent_loaded_records = {}   # Per memorizzare i record creati per i modelli parent
+    stats = {} # Statistiche: modello => numero di record caricati
+    parent_loaded_records = {} # Per memorizzare i record creati per i modelli parent
 
     ActiveRecord::Base.transaction do
       export_type = config[:configurations][:export_type]
@@ -106,11 +128,12 @@ module BetterSeeder
       end
     end
 
+    ActiveRecord::Base.logger.level = previous_log_level
     total_time = Time.now - start_time
     log_statistics(stats, total_time)
   end
 
-  def self.generate_structure(model_name: )
+  def self.generate_structure(model_name:)
     BetterSeeder::Builders::Structure.generate(model_name)
   end
 
@@ -146,12 +169,17 @@ module BetterSeeder
     # Recupera la configurazione specifica dal file di structure tramite il metodo seed_config.
     # Se non definito, vengono usati dei valori di default.
     seed_config = structure_class.respond_to?(:seed_config) ? structure_class.seed_config : {}
-    file_name        = seed_config[:file_name] || "#{model_name.underscore}_seed"
-    excluded_columns = seed_config.dig(:columns, :excluded) || []
-    generate_data    = seed_config.fetch(:generate_data, true)
-    count            = seed_config[:count] || 10
-    load_data        = seed_config.fetch(:load_data, true)
-    parent           = seed_config[:parent]   # nil oppure valore (o array) per modelli child
+    file_name = seed_config[:file_name] || "#{model_name.underscore}_seed"
+    excluded_columns = if export_type.to_s.downcase != 'sql'
+                         seed_config.dig(:columns, :excluded) || []
+                       else
+                         []
+                       end
+    generate_data = seed_config.fetch(:generate_data, true)
+    count = seed_config[:count] || 10
+    load_data = seed_config.fetch(:load_data, true)
+    parent = seed_config[:parent] # nil oppure valore (o array) per modelli child
+    superclass = seed_config[:superclass] # nil oppure valore (o array) per modelli child
 
     # Log per indicare se il modello è parent o child.
     message = if parent.nil?
@@ -170,74 +198,54 @@ module BetterSeeder
       raise Object.const_get(model_name)
     end
 
-    # Recupera o genera i record.
-    records = if generate_data
-                Farms::Farmer.generate(model: model_name, count: count)
-              else
-                model_class.all.map(&:attributes)
-              end
-
-    # Rimuove le colonne escluse.
-    processed_records = records.map do |record|
-      record.reject { |key, _| excluded_columns.include?(key.to_sym) }
+    # Se abilitato, carica i record nel database.
+    if load_data && File.exist?("#{BetterSeeder.configuration.preload_path.to_s}/#{seed_config[:file_name]}.sql")
+      load_data_from_file(seed_config)
+      stats[model_name] = model_class.all.count
+    else
+      if generate_data
+        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)
+        # 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
+        model_class.all.map(&:attributes)
+      end
     end
 
-    # Se il modello è child, inietta le foreign key.
-    if parent
-      Array(parent).each do |parent_model_name|
-        parent_records = parent_loaded_records[parent_model_name]
-        if parent_records.nil? || parent_records.empty?
-          message = "[ERROR] No loaded records found for parent model #{parent_model_name}. Cannot assign foreign key for #{model_name}."
-          BetterSeeder::Utils.logger(message: message)
-        else
-          # Il nome della foreign key è ottenuto prendendo l'ultima parte del nome del modello padre,
-          # trasformandola in minuscolo e in forma singolare, e aggiungendo "_id".
-          foreign_key = parent_model_name.split("::").last.underscore.singularize + "_id"
-          processed_records.each do |record|
-            record[foreign_key] = parent_records.sample.id
-          end
-        end
+    # Rimuove le colonne escluse.
+    unless 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))
       end
-    end
 
-    # Se abilitato, carica i record nel database.
-    if load_data
-      total_records = processed_records.size
-      stats[model_name] = total_records
-      created_records = load_records_into_db(model_class, processed_records, total_records, model_name)
-      # 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
-      stats[model_name] = 0
+      # Esporta i record nel formato richiesto.
+      export_records(model_class, processed_records, export_type, file_name)
     end
-
-    # Esporta i record nel formato richiesto.
-    export_records(model_class, processed_records, export_type, file_name)
   end
 
   # Carica i record nel database, utilizzando una progress bar per monitorare il progresso.
   # I log delle query SQL vengono temporaneamente disabilitati.
   #
   # @return [Array<Object>] Array dei record creati (istanze ActiveRecord)
-  def self.load_records_into_db(model_class, processed_records, total_records, model_name)
-    created_records = []
+  def self.load_records_into_db(model_class, processed_records, total_records, model_name, superclass)
     progressbar = ProgressBar.create(total: total_records, format: '%a %B %p%% %t')
     message = "[INFO] Starting to load #{total_records} records for model #{model_name}..."
     BetterSeeder::Utils.logger(message: message)
 
-    previous_level = ActiveRecord::Base.logger.level
-    ActiveRecord::Base.logger.level = Logger::ERROR
-
     processed_records.each do |record|
       created = model_class.create!(record)
-      created_records << created
+      BetterSeeder.store_generated_record(superclass || model_name, created)
       progressbar.increment
     end
 
-    ActiveRecord::Base.logger.level = previous_level
     message = "[INFO] Finished loading #{total_records} records into model #{model_name}."
     BetterSeeder::Utils.logger(message: message)
-    created_records
+
+    BetterSeeder.generated_records[model_name]
   end
 
   # Esporta i record nel formato specificato (json, csv, sql).
@@ -261,8 +269,8 @@ module BetterSeeder
 
   # Log finale con le statistiche raccolte e il tempo totale di esecuzione.
   def self.log_statistics(stats, total_time)
-    stats_message = stats.map { |model, count| "#{model}: #{count} records" }.join(", ")
-    message = "[INFO] Finished processing all models in #{total_time.round(2)} seconds. Statistics: #{stats_message}"
+    stats_message = stats.map { |model, count| "#{model}: #{count} records" }.join("\n")
+    message = "[INFO] Finished processing all models in #{total_time.round(2)} seconds. Statistics: \n#{stats_message}"
     BetterSeeder::Utils.logger(message: message)
   end
 
@@ -271,4 +279,29 @@ module BetterSeeder
   def self.transform_class_name(class_name)
     class_name.split("::").map(&:underscore).join("_")
   end
+
+  def self.load_data_from_file(seed_config)
+    config = seed_config
+    return unless config[:load_data] # Se load_data non è abilitato, esce senza fare nulla.
+
+    # Costruisce il nome del file di seed: ad esempio, se config[:file_name] è "my_model_seed",
+    # il file atteso sarà "my_model_seed_seed.sql".
+    seed_file_name = "#{config[:file_name]}.sql"
+    seed_file_path = File.join(BetterSeeder.configuration.preload_path, seed_file_name)
+
+    unless File.exist?(seed_file_path)
+      BetterSeeder::Utils.logger(message: "[WARN] Seed file not found: #{seed_file_path}")
+      return false
+    end
+
+    sql = File.read(seed_file_path)
+    begin
+      ActiveRecord::Base.connection.execute(sql)
+      BetterSeeder::Utils.logger(message: "[INFO] Loaded seed file: #{seed_file_path}")
+      true
+    rescue => e
+      BetterSeeder::Utils.logger(message: "[ERROR] Failed to load seed file: #{seed_file_path} - Error: #{e.message}")
+      false
+    end
+  end
 end

data/lib/generators/better_seeder/structure_generator.rb

@@ -0,0 +1,15 @@
+# lib/generators/better_seeder/structure_generator.rb
+require "rails/generators"
+
+module BetterSeeder
+  class StructureGenerator < Rails::Generators::NamedBase
+    # Optionally, if you have a template directory, you can set it here:
+    # source_root File.expand_path("templates", __dir__)
+
+    def create_structure_file
+      say_status("info", "Generating structure file for #{name}", :green)
+      file_path = BetterSeeder.generate_structure(model_name: name)
+      say_status("info", "Structure file created at #{file_path}", :green)
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: better_seeder
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.2.3
 platform: ruby
 authors:
 - alessio_bussolari
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-02-10 00:00:00.000000000 Z
+date: 2025-02-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffaker
@@ -143,7 +143,7 @@ files:
 - lib/better_seeder/structure/utils.rb
 - lib/better_seeder/utils.rb
 - lib/better_seeder/version.rb
-- lib/generators/better_seeder/structure/structure_generator.rb
+- lib/generators/better_seeder/structure_generator.rb
 homepage: https://github.com/alessiobussolari/better_seeder
 licenses:
 - MIT

data/lib/generators/better_seeder/structure/structure_generator.rb

@@ -1,17 +0,0 @@
-# lib/generators/better_seeder/structure/structure_generator.rb
-require "rails/generators"
-
-module BetterSeeder
-  module Structure
-    class StructureGenerator < Rails::Generators::NamedBase
-      # Optionally, if you have a template directory, you can set it here:
-      # source_root File.expand_path("templates", __dir__)
-
-      def create_structure_file
-        say_status("info", "Generating structure file for #{name}", :green)
-        file_path = BetterSeeder.generate_structure(model_name: name)
-        say_status("info", "Structure file created at #{file_path}", :green)
-      end
-    end
-  end
-end