factory_seeder 0.1.0

data/lib/factory_seeder/execution_log_store.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module FactorySeeder
+  # Temporary in-memory storage for execution logs
+  # Used to implement PRG pattern without session overflow
+  class ExecutionLogStore
+    EXPIRY_TIME = 300 # 5 minutes
+
+    class << self
+      def store(logs, flash_type: nil, flash_message: nil)
+        cleanup_expired
+        id = SecureRandom.hex(8)
+        storage[id] = {
+          logs: logs,
+          flash_type: flash_type,
+          flash_message: flash_message,
+          created_at: Time.now
+        }
+        id
+      end
+
+      def retrieve(id)
+        return nil if id.blank?
+
+        cleanup_expired
+        data = storage.delete(id)
+        return nil unless data
+
+        data
+      end
+
+      def clear
+        @storage = {}
+      end
+
+      private
+
+      def storage
+        @storage ||= {}
+      end
+
+      def cleanup_expired
+        cutoff = Time.now - EXPIRY_TIME
+        storage.delete_if { |_id, data| data[:created_at] < cutoff }
+      end
+    end
+  end
+end

data/lib/factory_seeder/factory_scanner.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+module FactorySeeder
+  class FactoryScanner
+    def initialize
+      @factories = {}
+      @factory_paths = find_factory_paths
+    end
+
+    def scan
+      # Setup Rails integration if available
+      FactorySeeder::RailsIntegration.setup
+      FactorySeeder::RailsIntegration.load_models
+
+      load_factories
+      analyze_factories
+      @factories
+    end
+
+    private
+
+    def find_factory_paths
+      paths = []
+
+      # Rails convention
+      paths << 'spec/factories' if Dir.exist?('spec/factories')
+      paths << 'test/factories' if Dir.exist?('test/factories')
+      paths << 'factories' if Dir.exist?('factories')
+
+      # Custom paths from configuration
+      paths.concat(FactorySeeder.configuration.factory_paths)
+
+      paths.uniq
+    end
+
+    def load_factories
+      @factory_paths.each do |path|
+        Dir.glob("#{path}/**/*.rb").each do |file|
+          load file
+        rescue FactoryBot::DuplicateDefinitionError => e
+          # Skip if factory is already registered
+          puts "⚠️  Factory already registered: #{e.message}" if FactorySeeder.configuration.verbose
+        rescue NameError => e
+          # Handle uninitialized constant errors
+          puts "⚠️  Model not loaded yet: #{e.message}" if FactorySeeder.configuration.verbose
+          # Store the file to retry later
+          @retry_files ||= []
+          @retry_files << file
+        rescue StandardError => e
+          # Handle other errors that might occur during factory loading
+          puts "⚠️  Error loading factory file #{file}: #{e.message}" if FactorySeeder.configuration.verbose
+        end
+      end
+
+      # Retry loading files that failed due to missing models
+      retry_loading_factories if @retry_files&.any?
+    end
+
+    def retry_loading_factories
+      return unless @retry_files&.any?
+
+      puts '🔄 Retrying to load factories that failed...' if FactorySeeder.configuration.verbose
+
+      # Try to load models again before retrying factories
+      FactorySeeder::RailsIntegration.load_models
+
+      @retry_files.each do |file|
+        load file
+        puts "✅ Successfully loaded: #{file}" if FactorySeeder.configuration.verbose
+      rescue StandardError => e
+        puts "❌ Still failed to load #{file}: #{e.message}" if FactorySeeder.configuration.verbose
+      end
+
+      @retry_files = []
+    end
+
+    def analyze_factories
+      FactoryBot.factories.each do |factory|
+        factory_name = factory.name.to_s
+        begin
+          # Use a safer approach to get class name without building the class
+          class_name = factory_name.classify
+
+          # Try to get the actual class name if possible, but don't fail if it doesn't work
+          begin
+            class_name = factory.build_class.name if factory.respond_to?(:build_class) && factory.build_class
+          rescue NameError, StandardError => e
+            # If we can't get the actual class name, use the inferred one
+            if FactorySeeder.configuration.verbose
+              puts "⚠️  Using inferred class name for '#{factory_name}': #{e.message}"
+            end
+          end
+
+          @factories[factory_name] = {
+            name: factory_name,
+            class_name: class_name,
+            traits: extract_traits(factory),
+            associations: extract_associations(factory),
+            attributes: extract_attributes(factory)
+          }
+        rescue NameError => e
+          # Skip factories with missing model classes
+          puts "⚠️  Skipping factory '#{factory_name}': #{e.message}" if FactorySeeder.configuration.verbose
+        rescue StandardError => e
+          # Skip factories with other errors
+          puts "⚠️  Error analyzing factory '#{factory_name}': #{e.message}" if FactorySeeder.configuration.verbose
+        end
+      end
+    end
+
+    def extract_traits(factory)
+      factory.definition.defined_traits.map(&:name).map(&:to_s)
+    end
+
+    def extract_associations(factory)
+      associations = []
+
+      factory.definition.declarations.each do |declaration|
+        next unless declaration.is_a?(FactoryBot::Declaration::Association)
+
+        # Try to get factory name from the association name
+        factory_name = declaration.name.to_s
+
+        associations << {
+          name: factory_name,
+          factory: factory_name.singularize, # Assume factory name matches association
+          strategy: 'create'
+        }
+      end
+
+      associations
+    end
+
+    def extract_attributes(factory)
+      attributes = []
+
+      factory.definition.declarations.each do |declaration|
+        next if declaration.is_a?(FactoryBot::Declaration::Association)
+
+        attributes << {
+          name: declaration.name.to_s,
+          type: declaration.class.name.demodulize.downcase
+        }
+      end
+
+      attributes
+    end
+  end
+end

data/lib/factory_seeder/loader.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'zeitwerk'
+
+module FactorySeeder
+  class Loader
+    class << self
+      def setup
+        return if @loader
+
+        @loader = Zeitwerk::Loader.new
+        @loader.inflector.inflect('cli' => 'CLI')
+        @loader.push_dir(File.expand_path(__dir__), namespace: FactorySeeder)
+        @loader.ignore("#{__dir__}/version.rb")
+        @loader.enable_reloading
+        @loader.setup
+      end
+
+      def reload!
+        return unless @loader&.reloading_enabled?
+
+        @loader.reload
+      end
+    end
+  end
+end

data/lib/factory_seeder/rails_integration.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module FactorySeeder
+  module RailsIntegration
+    def self.setup
+      return unless defined?(Rails)
+
+      # Force eager loading when Rails hasn't done it (development/test with lazy loading)
+      if Rails.respond_to?(:application) && Rails.application && !Rails.application.config.eager_load
+        Rails.application.eager_load!
+      end
+
+      # Add Rails-specific factory paths
+      FactorySeeder.configuration.factory_paths << 'spec/factories' if Dir.exist?('spec/factories')
+      FactorySeeder.configuration.factory_paths << 'test/factories' if Dir.exist?('test/factories')
+
+      # Enable verbose mode in development
+      FactorySeeder.configuration.verbose = Rails.env.development? if Rails.respond_to?(:env)
+    end
+
+    def self.load_models
+      return unless defined?(Rails) && Rails.respond_to?(:application) && Rails.application
+      return if Rails.application.config.eager_load
+
+      # Force eager loading when Rails hasn't done it (development/test with lazy loading)
+      Rails.application.eager_load!
+    end
+  end
+end

data/lib/factory_seeder/seed.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module FactorySeeder
+  class Seed
+    attr_reader :name, :description, :parameters, :block, :metadata
+
+    def initialize(name, description: nil, parameters: {}, metadata: {}, &block)
+      @name = name.to_sym
+      @description = description || "Seed for #{name}"
+      @parameters = parameters.transform_keys(&:to_sym)
+      @metadata = metadata.transform_keys(&:to_sym)
+      @block = block
+      @created_at = Time.now
+    end
+
+    def call(**kwargs)
+      validate_parameters!(kwargs)
+      @block.call(**kwargs)
+    end
+
+    def parameter_names
+      @parameters.keys
+    end
+
+    def has_parameters?
+      @parameters.any?
+    end
+
+    def parameter_info(name)
+      @parameters[name.to_sym]
+    end
+
+    def validate_parameters!(kwargs)
+      # Check for required parameters
+      required_params = @parameters.select { |_, info| info[:required] }.keys
+      missing_params = required_params - kwargs.keys
+
+      raise ArgumentError, "Missing required parameters: #{missing_params.join(', ')}" if missing_params.any?
+
+      # Validate parameter types and values
+      kwargs.each do |key, value|
+        param_info = @parameters[key]
+        next unless param_info
+
+        validate_parameter_type!(key, value, param_info)
+        validate_parameter_value!(key, value, param_info)
+      end
+    end
+
+    def to_h
+      {
+        name: @name,
+        description: @description,
+        parameters: @parameters,
+        metadata: @metadata,
+        created_at: @created_at,
+        has_parameters: has_parameters?
+      }
+    end
+
+    def to_json(*args)
+      to_h.to_json(*args)
+    end
+
+    private
+
+    def validate_parameter_type!(key, value, param_info)
+      expected_type = param_info[:type]
+      return unless expected_type
+      return unless value.present? && param_info[:required]
+
+      case expected_type
+      when :string
+        raise ArgumentError, "Parameter '#{key}' must be a string" unless value.is_a?(String)
+      when :integer
+        raise ArgumentError, "Parameter '#{key}' must be an integer" unless value.is_a?(Integer)
+      when :boolean
+        raise ArgumentError, "Parameter '#{key}' must be a boolean" unless [true, false].include?(value)
+      when :symbol
+        raise ArgumentError, "Parameter '#{key}' must be a symbol" unless value.is_a?(Symbol)
+      when :array
+        raise ArgumentError, "Parameter '#{key}' must be an array" unless value.is_a?(Array)
+      end
+    end
+
+    def validate_parameter_value!(key, value, param_info)
+      # Check allowed values
+      if param_info[:allowed_values] && !param_info[:allowed_values].include?(value)
+        raise ArgumentError, "Parameter '#{key}' must be one of: #{param_info[:allowed_values].join(', ')}"
+      end
+
+      # Check min/max for numeric values
+      if param_info[:min] && value < param_info[:min]
+        raise ArgumentError, "Parameter '#{key}' must be >= #{param_info[:min]}"
+      end
+
+      return unless param_info[:max] && value > param_info[:max]
+
+      raise ArgumentError, "Parameter '#{key}' must be <= #{param_info[:max]}"
+    end
+  end
+end

data/lib/factory_seeder/seed_builder.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module FactorySeeder
+  class SeedBuilder
+    def initialize(name)
+      @name = name
+      @description = nil
+      @parameters = {}
+      @metadata = {}
+    end
+
+    def description(text)
+      @description = text
+      self
+    end
+
+    def parameter(name, type: :string, required: false, default: nil, allowed_values: nil, min: nil, max: nil,
+                  description: nil)
+      # Validation des paramètres selon le type
+      validate_parameter_options(type, allowed_values: allowed_values, min: min, max: max)
+
+      @parameters[name.to_sym] = {
+        type: type,
+        required: required,
+        default: default,
+        allowed_values: allowed_values,
+        min: min,
+        max: max,
+        description: description
+      }
+      self
+    end
+
+    def metadata(key, value)
+      @metadata[key.to_sym] = value
+      self
+    end
+
+    def build(&block)
+      Seed.new(
+        @name,
+        description: @description,
+        parameters: @parameters,
+        metadata: @metadata,
+        &block
+      )
+    end
+
+    private
+
+    def validate_parameter_options(type, allowed_values:, min:, max:)
+      case type
+      when :integer
+        raise ArgumentError, 'allowed_values is not valid for integer type' if allowed_values
+      when :string, :symbol
+        raise ArgumentError, "min and max are not valid for #{type} type" if min || max
+      when :boolean
+        if min || max || allowed_values
+          raise ArgumentError,
+                'min, max, and allowed_values are not valid for boolean type'
+        end
+      when :array
+        raise ArgumentError, 'min, max, and allowed_values are not valid for array type' if min || max || allowed_values
+      end
+    end
+  end
+end