factory_seeder 0.1.0

data/app/views/factory_seeder/factory/show.html.erb

@@ -0,0 +1,108 @@
+<div class="page-shell" data-factory-name="<%= @factory_name %>">
+  <div class="scanlines"></div>
+  <div class="grid-background"></div>
+  <div class="page-content">
+    <header class="section-title">Factory · <%= @factory_name %></header>
+    <p class="hero__subtitle">
+      Configure the execution parameters for this factory, toggle traits, and send the
+      job to the generator.
+    </p>
+
+    <% if flash[:success] %>
+      <div class="alert-message alert-message--success"><%= flash[:success] %></div>
+    <% end %>
+
+    <% if flash[:error] %>
+      <div class="alert-message alert-message--error"><%= flash[:error] %></div>
+    <% end %>
+
+    <div class="factory-show-grid">
+      <section class="panel">
+        <div class="panel__header">
+          <div>
+            <div class="panel__title">Configuration</div>
+            <div class="factory-card__meta">Class: <%= @factory[:class_name] %></div>
+          </div>
+          <%= link_to "Back", factory_index_path, class: "btn btn-accent" %>
+        </div>
+
+        <%= form_tag generate_factory_path(@factory_name), method: :post do %>
+          <div class="panel__body">
+            <div class="form-group">
+              <label for="count">Records to generate</label>
+              <%= number_field_tag :count, 1, min: 1, max: 100, class: "form-control" %>
+            </div>
+
+            <% traits = Array(@factory[:traits]) %>
+            <% if traits.any? %>
+              <div class="form-group">
+                <label>Traits</label>
+                <div class="trait-grid">
+                  <% traits.each do |trait| %>
+                    <label class="trait-checkbox">
+                      <%= check_box_tag "selected_traits[]", trait, false, id: "trait_#{trait}" %>
+                      <span><%= trait %></span>
+                    </label>
+                  <% end %>
+                </div>
+              </div>
+            <% end %>
+
+            <div class="form-group">
+              <label>Associations</label>
+              <p class="factory-card__meta">
+                <%= Array(@factory[:associations]).map { |assoc| assoc[:name] }.join(', ').presence || 'None' %>
+              </p>
+            </div>
+
+            <div class="form-group">
+              <label>Attributes</label>
+              <div class="attribute-grid">
+                <% @factory[:attributes].each do |attr| %>
+                  <div class="attribute-row">
+                    <label for="attributes_<%= attr[:name] %>"><%= attr[:name] %> (<%= attr[:type] %>)</label>
+                    <%= text_field_tag "attributes[#{attr[:name]}]", nil, class: "form-control", placeholder: "Use default" %>
+                  </div>
+                <% end %>
+              </div>
+            </div>
+
+            <div class="form-actions">
+              <%= submit_tag "Generate Seeds", class: "btn btn-primary" %>
+            </div>
+          </div>
+        <% end %>
+      </section>
+
+      <section class="panel console">
+        <div class="console__header">
+          <span>Console Output</span>
+          <span class="factory-card__meta">Live logs will appear once a job runs.</span>
+        </div>
+        <div class="console__body">
+          <% logs = @execution_logs || [] %>
+              <% if logs.any? %>
+                <div class="space-y-1">
+                  <% logs.each do |log| %>
+                    <% entry = log.is_a?(Hash) ? log : log.to_h %>
+                    <% message = entry['message'] || entry[:message] || entry.to_s %>
+                    <% level = (entry['level'] || entry[:level] || :info).to_s %>
+                    <% timestamp_value = entry['timestamp'] || entry[:timestamp] || Time.now %>
+                    <% timestamp =
+                      timestamp_value.respond_to?(:strftime) ? timestamp_value.strftime('%H:%M:%S') : timestamp_value.to_s %>
+                    <div class="console-log console-log--<%= level %>">
+                      <span class="text-muted-foreground">[<%= timestamp %>]</span>
+                      <span><%= message %></span>
+                    </div>
+                  <% end %>
+                </div>
+              <% else %>
+                <div class="console-log">
+                  <span>[ --:--:-- ]</span>Awaiting execution trigger...
+                </div>
+              <% end %>
+        </div>
+      </section>
+    </div>
+  </div>
+</div>

data/app/views/factory_seeder/seeds/show.html.erb

@@ -0,0 +1,2 @@
+<h1>Seed: <%= @seed.name %></h1>
+

data/app/views/layouts/factory_seeder/application.html.erb

@@ -0,0 +1,25 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>FactorySeeder - Database Seeding Made Easy</title>
+    <%= csrf_meta_tags %>
+    <%= csp_meta_tag %>
+    
+    <!-- FactorySeeder CSS -->
+    <style>
+      <%= raw FactorySeeder::AssetHelper.css_content('factory_seeder.css') %>
+    </style>
+  </head>
+  <body>
+    <header class="app-header">
+      <div>
+        <div class="app-header__title">FACTORY / SEEDER by Wecasa</div>
+        <div class="app-header__tagline">Industrial-quality seeds powered by FactoryBot</div>
+      </div>
+      <%= link_to "Dashboard", root_path, class: "app-header__link" %>
+    </header>
+    <%= yield %>
+  </body>
+</html>

data/bin/factory_seeder

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Essayer de charger l'environnement Rails s'il existe
+begin
+  # Chercher le fichier config/environment.rb dans le répertoire courant ou parent
+  current_dir = Dir.pwd
+  rails_env_found = false
+
+  # Chercher dans le répertoire courant et ses parents
+  while current_dir != '/' && !rails_env_found
+    if File.exist?(File.join(current_dir, 'config', 'environment.rb'))
+      require File.join(current_dir, 'config', 'environment')
+      rails_env_found = true
+      puts "🌱 Rails environment chargé depuis: #{current_dir}" if ENV['FACTORY_SEEDER_DEBUG']
+    else
+      current_dir = File.dirname(current_dir)
+    end
+  end
+rescue LoadError => e
+  puts "⚠️  Rails environment non trouvé: #{e.message}" if ENV['FACTORY_SEEDER_DEBUG']
+end
+
+require 'bundler/setup'
+require 'factory_seeder'
+
+FactorySeeder::CLI.start(ARGV)

data/config/factory_seeder.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+# FactorySeeder Configuration
+FactorySeeder.configure do |config|
+  # Add custom factory paths if needed
+  # config.factory_paths << "custom/factories"
+
+  # Default options for seeding
+  config.default_count = 1
+  config.default_strategy = :create
+
+  # Environment-specific settings
+  config.environments = {
+    development: {
+      default_count: 10
+    },
+    test: {
+      default_count: 5
+    },
+    production: {
+      default_count: 1
+    }
+  }
+end

data/config/routes.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+FactorySeeder::Engine.routes.draw do
+  # Dashboard principal
+  root 'dashboard#index'
+
+  # Factory details et génération
+  get '/factory/:name', to: 'factory#show', as: :factory
+  get '/factory', to: 'factory#index', as: :factory_index
+  post '/factory/:name/generate', to: 'factory#generate', as: :generate_factory
+
+  # Seeds actions
+  post '/seeds/:name', to: 'dashboard#run_seed', as: :run_seed
+  post '/seeds', to: 'dashboard#run_all_seeds', as: :run_all_seeds
+
+  # Custom seeds
+  get '/custom_seeds', to: 'custom_seeds#index', as: :custom_seeds
+  get '/custom_seeds/:name', to: 'custom_seeds#show', as: :custom_seed
+  post '/custom_seeds/:name/generate', to: 'custom_seeds#create', as: :create_custom_seede
+end

data/lib/factory_seeder/asset_helper.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module FactorySeeder
+  module AssetHelper
+    def self.javascript_path(filename)
+      # Dans une gem, on peut servir les assets directement depuis le dossier app/assets
+      File.join(File.dirname(__FILE__), '..', '..', 'app', 'assets', 'javascript', filename)
+    end
+
+    def self.stylesheet_path(filename)
+      File.join(File.dirname(__FILE__), '..', '..', 'app', 'assets', 'stylesheets', filename)
+    end
+
+    def self.asset_content(filename)
+      path = javascript_path(filename)
+      File.read(path) if File.exist?(path)
+    end
+
+    def self.css_content(filename)
+      path = stylesheet_path(filename)
+      File.read(path) if File.exist?(path)
+    end
+
+    def self.available_assets
+      js_dir = File.join(File.dirname(__FILE__), '..', '..', 'app', 'assets', 'javascript')
+      Dir.glob(File.join(js_dir, '*.js')).map { |f| File.basename(f) }
+    end
+
+    def self.available_stylesheets
+      css_dir = File.join(File.dirname(__FILE__), '..', '..', 'app', 'assets', 'stylesheets')
+      Dir.glob(File.join(css_dir, '*.css')).map { |f| File.basename(f) }
+    end
+  end
+end

data/lib/factory_seeder/cli.rb

@@ -0,0 +1,352 @@
+# frozen_string_literal: true
+
+require 'thor'
+
+module FactorySeeder
+  class CLI < Thor
+    class_option :verbose, type: :boolean, aliases: '-v', desc: 'Enable verbose output'
+
+    desc 'generate [FACTORY]', 'Generate seeds for a specific factory'
+    option :count, type: :numeric, desc: 'Number of records to create (defaults to config per environment)'
+    option :traits, type: :array, desc: 'Traits to apply'
+    option :strategy, type: :string, desc: 'Factory strategy (defaults to config per environment)'
+    option :attributes, type: :hash, desc: 'Additional attributes'
+    def generate(factory_name = nil)
+      if factory_name
+        generate_single_factory(factory_name)
+      else
+        interactive_generate
+      end
+    end
+
+    desc 'list', 'List all available factories with metadata'
+    option :verbose, type: :boolean, aliases: '-v'
+    def list
+      FactorySeeder.configuration.verbose = options[:verbose] if options[:verbose]
+
+      factories = FactorySeeder.scan_factories
+
+      if factories.empty?
+        puts '❌ No factories found. Make sure you have FactoryBot factories in spec/factories/ or test/factories/'
+        return
+      end
+
+      puts "📋 Found #{factories.count} factories:\n\n"
+
+      factories.sort.each do |name, info|
+        puts "🏭 #{name} (#{info[:class_name] || 'Unknown class'})"
+        puts "   Traits: #{formatted_traits(info[:traits])}"
+        puts "   Associations: #{formatted_associations(info[:associations])}"
+        puts "   Attributes: #{formatted_attributes(info[:attributes])}"
+        puts
+      end
+    end
+
+    desc 'preview FACTORY_NAME', 'Preview factory data without creating records'
+    option :count, type: :numeric, aliases: '-c', desc: 'Number of preview records (defaults to config per environment)'
+    option :traits, type: :string, aliases: '-t'
+    option :attributes, type: :string, aliases: '-a'
+    def preview(factory_name)
+      FactorySeeder.configuration.verbose = true
+
+      # Vérifier si la factory existe
+      factory_names = FactorySeeder.list_factory_names
+      unless factory_names.include?(factory_name)
+        puts "❌ Factory '#{factory_name}' not found"
+        puts "Available factories: #{factory_names.first(10).join(', ')}"
+        return
+      end
+
+      traits = options[:traits]&.split(',')&.map(&:strip) || []
+      attributes = parse_attributes(options[:attributes])
+
+      generator = SeedGenerator.new
+      preview_data = generator.preview(factory_name, resolved_count, traits, attributes)
+
+      puts "🔍 Preview for #{factory_name}:"
+      puts JSON.pretty_generate(preview_data)
+    end
+
+    desc 'web', 'Start web interface'
+    option :port, type: :numeric, default: 4567, aliases: '-p'
+    option :host, type: :string, default: 'localhost', aliases: '-h'
+    def web
+      puts "🌐 Starting FactorySeeder web interface on http://#{options[:host]}:#{options[:port]}"
+      puts 'Press Ctrl+C to stop'
+
+      WebInterface.set :port, options[:port]
+      WebInterface.set :bind, options[:host]
+      WebInterface.run!
+    end
+
+    desc 'init', 'Initialize FactorySeeder configuration'
+    def init
+      puts '🚀 Initializing FactorySeeder...'
+
+      seeds_file = Rails.root.join('db/seeds_factory_seeder.rb')
+      unless File.exist?(seeds_file)
+        File.write(seeds_file, <<~RUBY)
+          # FactorySeeder Seeds
+          # This file is automatically generated by FactorySeeder
+
+          FactorySeeder.generate do |seeder|
+            # Add your custom seeds here
+          end
+        RUBY
+        puts "✅ Seeds file created: #{seeds_file}"
+      end
+
+      initializer_file = Rails.root.join('config/initializers/factory_seeder.rb')
+      unless File.exist?(initializer_file)
+        File.write(initializer_file, <<~RUBY)
+          # frozen_string_literal: true
+          # FactorySeeder initializer
+          # This file is generated by FactorySeeder
+
+          FactorySeeder.configure do |config|
+            config.factory_paths << Rails.root.join('spec/factories').to_s if Dir.exist?('spec/factories')
+            config.factory_paths << Rails.root.join('test/factories').to_s if Dir.exist?('test/factories')
+            config.verbose = true
+          end
+
+          # Load custom seeds so they are available at boot
+          seeds_file = Rails.root.join('db/seeds_factory_seeder.rb')
+          load seeds_file if File.exist?(seeds_file)
+        RUBY
+
+        puts "✅ Initializer created: #{initializer_file}"
+      end
+
+      puts '✅ FactorySeeder initialized!'
+      puts "  Factory paths: #{FactorySeeder.configuration.factory_paths.join(', ')}"
+      puts "  Verbose mode: #{FactorySeeder.configuration.verbose}"
+    end
+
+    desc 'seeds [SEED_NAME]', 'Run seeds from db/seeds_factory_seeder.rb'
+    option :list, type: :boolean, default: false, desc: 'List all available seeds'
+    option :all, type: :boolean, default: false, desc: 'Run all defined seeds'
+    option :dry_run, type: :boolean, default: false, desc: 'Preview what would be generated'
+    def seeds(seed_name = nil)
+      seeds_file = 'db/seeds_factory_seeder.rb'
+
+      unless File.exist?(seeds_file)
+        puts "❌ Seeds file not found: #{seeds_file}"
+        puts "💡 Run 'factory_seeder init' to create the default seeds file"
+        return
+      end
+
+      # Charger le fichier de seeds pour avoir accès aux seeds définis
+      load seeds_file
+
+      if options[:list]
+        list_available_seeds
+        return
+      end
+
+      if options[:all]
+        run_all_seeds
+        return
+      end
+
+      if seed_name.nil?
+        puts '❌ Please specify a seed name, use --list to see available seeds, or --all to run all seeds'
+        puts '💡 Example: factory_seeder seeds development'
+        return
+      end
+
+      run_specific_seed(seed_name)
+    end
+
+    private
+
+    def list_available_seeds
+      # Créer un générateur temporaire pour lister les seeds
+      generator = SeedGenerator.new
+
+      # Charger le fichier de seeds pour avoir accès aux seeds définis
+      load 'db/seeds_factory_seeder.rb'
+
+      seeds = generator.list_seeds
+
+      if seeds.empty?
+        puts '❌ No seeds defined in db/seeds_factory_seeder.rb'
+        puts '�� Add seeds using seeder.define_seed :name do ... end'
+        return
+      end
+
+      puts "🌱 Available seeds from db/seeds_factory_seeder.rb:\n\n"
+      seeds.each do |seed_name|
+        puts "  • #{seed_name}"
+      end
+
+      puts "\n💡 Run: factory_seeder seeds SEED_NAME"
+      puts '💡 Example: factory_seeder seeds development'
+      puts '💡 Run all: factory_seeder seeds --all'
+    end
+
+    def run_all_seeds
+      puts '🌱 Running all seeds from db/seeds_factory_seeder.rb'
+
+      puts '🔍 DRY RUN MODE - No records will be created' if options[:dry_run]
+
+      begin
+        generator = SeedGenerator.new
+        generator.run_all_seeds
+        puts '✅ All seeds executed successfully'
+      rescue StandardError => e
+        puts "❌ Error running seeds: #{e.message}"
+        puts e.backtrace.first(5).join("\n") if options[:verbose]
+      end
+    end
+
+    def run_specific_seed(seed_name)
+      puts "🌱 Running seed: #{seed_name}"
+
+      puts '🔍 DRY RUN MODE - No records will be created' if options[:dry_run]
+
+      begin
+        generator = SeedGenerator.new
+
+        # Charger le fichier de seeds pour avoir accès aux seeds définis
+        load 'db/seeds_factory_seeder.rb'
+
+        unless generator.has_seed?(seed_name)
+          puts "❌ Seed '#{seed_name}' not found"
+          puts "💡 Available seeds: #{generator.list_seeds.join(', ')}"
+          return
+        end
+
+        generator.run_seed(seed_name)
+        puts "✅ Seed '#{seed_name}' executed successfully"
+      rescue StandardError => e
+        puts "❌ Error running seed '#{seed_name}': #{e.message}"
+        puts e.backtrace.first(5).join("\n") if options[:verbose]
+      end
+    end
+
+    def interactive_generate
+      factory_names = FactorySeeder.list_factory_names
+
+      if factory_names.empty?
+        puts '❌ No factories found'
+        return
+      end
+
+      puts '🏭 Available factories:'
+      factory_names.each_with_index do |name, index|
+        puts "  #{index + 1}. #{name}"
+      end
+
+      print "\nSelect factory (number or name): "
+      selection = $stdin.gets.chomp
+
+      factory_name = if selection.match?(/^\d+$/)
+                       index = selection.to_i - 1
+                       factory_names[index]
+                     else
+                       selection
+                     end
+
+      unless factory_name && factory_names.include?(factory_name)
+        puts '❌ Invalid selection'
+        return
+      end
+
+      generate_single_factory(factory_name)
+    end
+
+    def generate_single_factory(factory_name)
+      # Vérifier si la factory existe
+      factory_names = FactorySeeder.list_factory_names
+      unless factory_names.include?(factory_name)
+        puts "❌ Factory '#{factory_name}' not found"
+        return
+      end
+
+      traits = options[:traits] || []
+      attributes = options[:attributes] || {}
+      count = resolved_count
+      strategy = resolved_strategy
+
+      generator = SeedGenerator.new
+      result = generator.generate(factory_name, count, traits, attributes, strategy)
+
+      puts "✅ Generated #{result[:count]} #{factory_name} records"
+      puts "Strategy: #{result[:strategy]}"
+      puts "Traits: #{traits.join(', ')}" if traits.any?
+      puts "Attributes: #{attributes}" if attributes.any?
+    end
+
+    def parse_attributes(attributes_string)
+      return {} unless attributes_string
+
+      trimmed = attributes_string.strip
+      if trimmed.start_with?('{') && trimmed.end_with?('}')
+        JSON.parse(trimmed)
+      else
+        parse_attribute_pairs(trimmed)
+      end
+    rescue JSON::ParserError => e
+      puts "⚠️  Could not parse attributes JSON: #{e.message}" if FactorySeeder.configuration.verbose
+      parse_attribute_pairs(attributes_string)
+    end
+
+    def parse_attribute_pairs(attributes_string)
+      attributes = {}
+      attributes_string.split(',').each do |pair|
+        next if pair.strip.empty?
+        key, value = pair.split('=').map(&:strip)
+        attributes[key] = value if key && value
+      end
+      attributes
+    end
+
+    def resolved_count
+      options[:count] || FactorySeeder.configuration.default_count_for_environment
+    end
+
+    def resolved_strategy
+      (options[:strategy] || FactorySeeder.configuration.default_strategy_for_environment).to_s
+    end
+
+    def formatted_traits(traits)
+      traits = Array(traits)
+      return 'None' if traits.empty?
+
+      traits.join(', ')
+    end
+
+    def formatted_associations(associations)
+      associations = Array(associations)
+      return 'None' if associations.empty?
+
+      associations.map { |assoc| format_association(assoc) }.join(', ')
+    end
+
+    def formatted_attributes(attributes)
+      attributes = Array(attributes)
+      return 'None' if attributes.empty?
+
+      attributes.map do |attribute|
+        name = attribute[:name] || attribute['name']
+        type = attribute[:type] || attribute['type']
+        type_part = type ? " (#{type})" : ''
+        "#{name || 'unknown'}#{type_part}"
+      end.join(', ')
+    end
+
+    def format_association(association)
+      return association.to_s unless association.respond_to?(:[])
+
+      name = association[:name] || association['name'] || 'association'
+      parts = []
+      factory = association[:factory] || association['factory']
+      strategy = association[:strategy] || association['strategy']
+      parts << "factory: #{factory}" if factory
+      parts << "strategy: #{strategy}" if strategy
+      return name if parts.empty?
+
+      "#{name} (#{parts.join(', ')})"
+    end
+  end
+end

data/lib/factory_seeder/configuration.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module FactorySeeder
+  class Configuration
+    attr_accessor :factory_paths, :default_count, :default_strategy, :environments, :verbose
+
+    def initialize
+      @factory_paths = []
+      @default_count = 1
+      @default_strategy = :create
+      @verbose = false
+      @environments = {
+        development: { default_count: 10 },
+        test: { default_count: 5 },
+        production: { default_count: 1 }
+      }
+    end
+
+    def environment_settings
+      current_env = ENV['RAILS_ENV'] || ENV['RACK_ENV'] || 'development'
+      @environments[current_env.to_sym] || @environments[:development]
+    end
+
+    def default_count_for_environment
+      environment_settings[:default_count] || @default_count
+    end
+
+    def default_strategy_for_environment
+      environment_settings[:default_strategy] || @default_strategy
+    end
+  end
+end

data/lib/factory_seeder/custom_seed_loader.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'pathname'
+
+module FactorySeeder
+  class CustomSeedLoader
+    class << self
+      def reload!
+        return unless seed_files.any?
+
+        FactorySeeder.seed_manager.clear
+        seed_files.each do |file|
+          load file
+        rescue StandardError => e
+          warn "⚠️  Could not load custom seed #{file}: #{e.message}"
+        end
+      end
+
+      def seed_files
+        return [] unless seeds_directory
+
+        Dir.glob(seeds_directory.join('**/*.rb'))
+      end
+
+      def seeds_directory
+        base_path = if defined?(Rails) && Rails.respond_to?(:root)
+                      Rails.root
+                    else
+                      Pathname.new(Dir.pwd)
+                    end
+
+        path = base_path.join('db', 'factory_seeds')
+        return path if path.exist?
+
+        nil
+      end
+    end
+  end
+end

data/lib/factory_seeder/engine.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module FactorySeeder
+  class Engine < ::Rails::Engine
+    isolate_namespace FactorySeeder
+
+    config.generators do |g|
+      g.test_framework :rspec
+      g.template_engine :erb
+    end
+
+    config.to_prepare do
+      FactorySeeder::CustomSeedLoader.reload!
+    end
+  end
+end