factory_seeder 0.1.0

data/lib/factory_seeder/seed_generator.rb

@@ -0,0 +1,305 @@
+# frozen_string_literal: true
+
+module FactorySeeder
+  class SeedGenerator
+    def initialize
+      @generated_records = []
+      @defined_seeds = {}
+    end
+
+    def preview(factory_name, count = 1, traits = [], attributes = {})
+      traits = traits.map(&:to_sym)
+      filtered_attributes = filter_association_attributes(factory_name, attributes)
+
+      preview_data = []
+      count.times do |i|
+        begin
+          # Build without saving
+          record = FactoryBot.build(factory_name, *traits, filtered_attributes)
+        rescue NoMethodError => e
+          # Check if this is the specific error about calling a method on CollectionProxy
+          raise unless e.message.include?('CollectionProxy') && e.message.include?('undefined method')
+
+          method_name = e.message.match(/undefined method `(\w+)'/)&.[](1)
+          # Try to identify which attribute might be causing the issue
+          problematic_attrs = attributes.select { |k, v| v.to_s == method_name || k.to_s == method_name }
+          if problematic_attrs.any?
+            raise NoMethodError,
+                  "#{e.message}. This might be caused by passing '#{problematic_attrs.keys.first}' as an attribute. Collection associations (has_many, has_and_belongs_to_many) cannot be set directly via attributes."
+          else
+            raise NoMethodError,
+                  "#{e.message}. This might be caused by an attribute that matches an association name. Try removing association-related attributes from your attributes hash."
+          end
+        end
+
+        preview_data << {
+          index: i + 1,
+          attributes: record.attributes,
+          associations: extract_associations(record)
+        }
+      rescue StandardError => e
+        preview_data << {
+          index: i + 1,
+          error: e.message
+        }
+      end
+
+      {
+        factory: factory_name,
+        count: count,
+        traits: traits,
+        attributes: attributes,
+        preview: preview_data
+      }
+    end
+
+    def generate(factory_name, count = 1, traits = [], attributes = {}, strategy = 'create')
+      traits = traits.map(&:to_sym)
+      filtered_attributes = filter_association_attributes(factory_name, attributes)
+
+      FactorySeeder.clear_execution_logs!
+      FactorySeeder.log_info("Starting #{factory_name} generation", count: count, traits: traits, strategy: strategy)
+
+      generated_count = 0
+      errors = []
+
+      count.times do |i|
+        begin
+          if strategy == 'create'
+            record = FactoryBot.create(factory_name, *traits, filtered_attributes)
+          else
+            record = FactoryBot.build(factory_name, *traits, filtered_attributes)
+            record.save! if record.respond_to?(:save!)
+          end
+        rescue NoMethodError => e
+          # Check if this is the specific error about calling a method on CollectionProxy
+          raise unless e.message.include?('CollectionProxy') && e.message.include?('undefined method')
+
+          method_name = e.message.match(/undefined method `(\w+)'/)&.[](1)
+          # Try to identify which attribute might be causing the issue
+          problematic_attrs = attributes.select { |k, v| v.to_s == method_name || k.to_s == method_name }
+          if problematic_attrs.any?
+            raise NoMethodError,
+                  "#{e.message}. This might be caused by passing '#{problematic_attrs.keys.first}' as an attribute. Collection associations (has_many, has_and_belongs_to_many) cannot be set directly via attributes."
+          else
+            raise NoMethodError,
+                  "#{e.message}. This might be caused by an attribute that matches an association name. Try removing association-related attributes from your attributes hash."
+          end
+        end
+
+        @generated_records << {
+          factory: factory_name,
+          record: record,
+          traits: traits,
+          attributes: attributes,
+          strategy: strategy
+        }
+
+        generated_count += 1
+
+        FactorySeeder.log("✅ Generated #{factory_name} ##{i + 1}", level: :success)
+        puts "✅ Generated #{factory_name} ##{i + 1}" if FactorySeeder.configuration.verbose
+      rescue StandardError => e
+        error_msg = "Failed to generate #{factory_name} ##{i + 1}: #{e.message}"
+        errors << error_msg
+        FactorySeeder.log(error_msg, level: :error)
+        puts "❌ #{error_msg}" if FactorySeeder.configuration.verbose
+      end
+
+      FactorySeeder.log_info('Completed generation', generated_count: generated_count, errors: errors.count)
+      logs = FactorySeeder.normalized_logs(FactorySeeder.execution_logs)
+      FactorySeeder.clear_execution_logs!
+
+      {
+        factory: factory_name,
+        generated_records: @generated_records,
+        count: generated_count,
+        requested_count: count,
+        traits: traits,
+        attributes: attributes,
+        strategy: strategy,
+        errors: errors,
+        logs: logs
+      }
+    end
+
+    def summary
+      return 'No records generated' if @generated_records.empty?
+
+      summary = "📊 Generation Summary:\n"
+      summary += "#{'=' * 50}\n"
+
+      by_factory = @generated_records.group_by { |r| r[:factory] }
+
+      by_factory.each do |factory_name, records|
+        summary += "\n🏭 #{factory_name}: #{records.count} records\n"
+        records.each_with_index do |record, index|
+          summary += "   #{index + 1}. Strategy: #{record[:strategy]}"
+          summary += ", Traits: #{record[:traits].join(', ')}" if record[:traits].any?
+          summary += ", Attributes: #{record[:attributes]}" if record[:attributes].any?
+          summary += "\n"
+        end
+      end
+
+      summary
+    end
+
+    def define_seed(name, &block)
+      @defined_seeds[name.to_sym] = block
+    end
+
+    def run_seed(name)
+      seed_name = name.to_sym
+      unless @defined_seeds.key?(seed_name)
+        raise "Seed '#{name}' not found. Available seeds: #{@defined_seeds.keys.join(', ')}"
+      end
+
+      @defined_seeds[seed_name].call(self)
+    end
+
+    def list_seeds
+      @defined_seeds.keys
+    end
+
+    def has_seed?(name)
+      @defined_seeds.key?(name.to_sym)
+    end
+
+    def run_all_seeds
+      puts '🌱 Running all defined seeds...'
+      @defined_seeds.each do |name, block|
+        puts "\n--- Running seed: #{name} ---"
+        block.call(self)
+      end
+      puts "\n✅ All seeds completed successfully"
+    end
+
+    private
+
+    def filter_association_attributes(factory_name, attributes)
+      return attributes if attributes.empty?
+
+      begin
+        # Get the factory
+        factory = FactoryBot.factories.find { |f| f.name.to_s == factory_name.to_s }
+        return attributes unless factory
+
+        # Get associations from factory definition
+        factory_associations = []
+        factory.definition.declarations.each do |declaration|
+          factory_associations << declaration.name.to_s if declaration.is_a?(FactoryBot::Declaration::Association)
+        end
+
+        # Get the model class from the factory
+        model_class = factory.build_class
+        model_associations = []
+
+        if model_class.respond_to?(:reflect_on_all_associations)
+          # Get all has_many and has_and_belongs_to_many associations from the model
+          model_associations = model_class.reflect_on_all_associations.select do |assoc|
+            %i[has_many has_and_belongs_to_many].include?(assoc.macro)
+          end.map { |assoc| assoc.name.to_s }
+        end
+
+        # Combine factory and model associations
+        all_collection_associations = (factory_associations + model_associations).uniq
+
+        # Get all associations (including belongs_to and has_one) for additional safety
+        all_associations = []
+        if model_class.respond_to?(:reflect_on_all_associations)
+          all_associations = model_class.reflect_on_all_associations.map { |assoc| assoc.name.to_s }
+        end
+        all_associations = (all_associations + factory_associations).uniq
+
+        # Filter out attributes that match collection associations
+        filtered = attributes.dup
+        all_collection_associations.each do |assoc_name|
+          filtered.delete(assoc_name.to_sym)
+          filtered.delete(assoc_name.to_s)
+        end
+
+        # Additional safety: filter out any attribute whose value is a symbol
+        # and whose key matches an association name (to prevent method calls on associations)
+        filtered_before_symbol_check = filtered.dup
+        filtered.delete_if do |key, value|
+          key_str = key.to_s
+          # If the value is a symbol and the key matches an association name,
+          # FactoryBot might try to call that symbol as a method on the association
+          if value.is_a?(Symbol) && all_associations.include?(key_str)
+            if FactorySeeder.configuration.verbose
+              puts "🔍 Filtering attribute '#{key_str}' (value: #{value}) - matches association name"
+            end
+            true
+          # Also filter if key looks like an association name (plural, ends with _ids, etc.)
+          elsif value.is_a?(Symbol) && (
+            key_str.end_with?('_ids') ||
+            (key_str.pluralize == key_str && key_str.singularize != key_str)
+          )
+            # Double-check if it's actually an association
+            if model_class.respond_to?(:reflect_on_all_associations)
+              association = model_class.reflect_on_association(key_str.singularize.to_sym) ||
+                            model_class.reflect_on_association(key_str.to_sym)
+              if !association.nil?
+                if FactorySeeder.configuration.verbose
+                  puts "🔍 Filtering attribute '#{key_str}' (value: #{value}) - detected as association"
+                end
+                true
+              else
+                false
+              end
+            else
+              false
+            end
+          else
+            false
+          end
+        end
+
+        if FactorySeeder.configuration.verbose && filtered_before_symbol_check != filtered
+          removed = filtered_before_symbol_check.keys - filtered.keys
+          puts "🔍 Filtered out #{removed.count} association-related attributes: #{removed.join(', ')}" if removed.any?
+        end
+
+        filtered
+      rescue StandardError => e
+        # If we can't determine associations, try a more aggressive filter
+        # Filter out any attribute that might be problematic
+        filtered = attributes.dup
+
+        # Remove any attribute whose value is a symbol (which FactoryBot might try to call as a method)
+        # but only if we're not sure it's safe
+        filtered.delete_if do |key, value|
+          # If value is a symbol and key looks like it could be an association name
+          value.is_a?(Symbol) && (
+            key.to_s.end_with?('_ids') ||
+            key.to_s.pluralize == key.to_s ||
+            key.to_s.singularize != key.to_s
+          )
+        end
+
+        if FactorySeeder.configuration.verbose
+          puts "⚠️  Warning: Could not fully filter association attributes: #{e.message}"
+        end
+        filtered
+      end
+    end
+
+    def extract_associations(record)
+      associations = {}
+
+      record.class.reflect_on_all_associations.each do |association|
+        if association.macro == :belongs_to
+          associated_record = record.send(association.name)
+          associations[association.name] = associated_record&.id if associated_record
+        elsif association.macro == :has_many
+          associated_records = record.send(association.name)
+          associations[association.name] = associated_records.map(&:id) if associated_records.any?
+        end
+      rescue StandardError => e
+        associations[association.name] = "Error: #{e.message}"
+      end
+
+      associations
+    end
+  end
+end

data/lib/factory_seeder/seed_manager.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+module FactorySeeder
+  class SeedManager
+    attr_reader :seeds
+
+    def initialize
+      @seeds = {}
+    end
+
+    def register(seed)
+      raise ArgumentError, 'Seed must be a FactorySeeder::Seed instance' unless seed.is_a?(Seed)
+
+      @seeds[seed.name] = seed
+    end
+
+    def define(name, builder_block = nil, &execution_block)
+      builder = SeedBuilder.new(name)
+      builder_block&.call(builder)
+      seed = builder.build(&execution_block)
+      register(seed)
+      seed
+    end
+
+    def find(name)
+      @seeds[name.to_sym]
+    end
+
+    def exists?(name)
+      @seeds.key?(name.to_sym)
+    end
+
+    def list
+      @seeds.values
+    end
+
+    def list_names
+      @seeds.keys
+    end
+
+    def run(name, **kwargs)
+      seed = find(name)
+      raise ArgumentError, "Seed '#{name}' not found" unless seed
+
+      FactorySeeder.clear_execution_logs!
+      FactorySeeder.log_info("Running custom seed '#{name}'", kwargs: kwargs)
+
+      begin
+        result = seed.call(**kwargs)
+        FactorySeeder.log_success("Seed '#{name}' completed", result: result)
+        logs = FactorySeeder.normalized_logs(FactorySeeder.execution_logs)
+        FactorySeeder.clear_execution_logs!
+        {
+          success: true,
+          seed_name: name,
+          result: result,
+          message: "Seed '#{name}' executed successfully",
+          logs: logs
+        }
+      rescue StandardError => e
+        FactorySeeder.log("Seed '#{name}' failed: #{e.message}", level: :error)
+        logs = FactorySeeder.normalized_logs(FactorySeeder.execution_logs)
+        FactorySeeder.clear_execution_logs!
+        {
+          success: false,
+          seed_name: name,
+          error: e.message,
+          message: "Seed '#{name}' failed: #{e.message}",
+          logs: logs
+        }
+      end
+    end
+
+    def run_all(**global_kwargs)
+      results = []
+
+      @seeds.each_key do |name|
+        result = run(name, **global_kwargs)
+        results << result
+      end
+
+      {
+        total_seeds: @seeds.count,
+        successful: results.count { |r| r[:success] },
+        failed: results.count { |r| !r[:success] },
+        results: results
+      }
+    end
+
+    def validate_seed(name, **kwargs)
+      seed = find(name)
+      raise ArgumentError, "Seed '#{name}' not found" unless seed
+
+      seed.validate_parameters!(kwargs)
+      true
+    rescue StandardError
+      false
+    end
+
+    def get_seed_info(name)
+      seed = find(name)
+      return nil unless seed
+
+      seed.to_h
+    end
+
+    def search(query)
+      query = query.to_s.downcase
+      @seeds.values.select do |seed|
+        seed.name.to_s.downcase.include?(query) ||
+          seed.description.downcase.include?(query) ||
+          seed.parameter_names.any? { |param| param.to_s.downcase.include?(query) }
+      end
+    end
+
+    def clear
+      @seeds.clear
+    end
+
+    def count
+      @seeds.count
+    end
+
+    def empty?
+      @seeds.empty?
+    end
+  end
+end

data/lib/factory_seeder/seeder.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module FactorySeeder
+  class Seeder
+    attr_reader :seeds
+
+    def initialize
+      @seeds = {}
+    end
+
+    def seed(name, &block)
+      @seeds[name.to_sym] = block
+    end
+
+    def run(name, **kwargs)
+      name = to_sym(name)
+      seed = @seeds[name]
+
+      raise ArgumentError, "Seed #{name} not defined" unless seed
+
+      result = @seeds[name].call(**kwargs)
+      if result
+        puts "🌱 Seed #{name} generated successfully"
+        true
+      else
+        puts "⚠️  Seed #{name} failed"
+        false
+      end
+    end
+
+    private
+
+    def to_sym(name)
+      if name.is_a?(Symbol)
+        name
+      else
+        name.to_sym
+      end
+    end
+  end
+end

data/lib/factory_seeder/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module FactorySeeder
+  VERSION = '0.1.0'
+end

data/lib/factory_seeder/web_interface.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require 'sinatra/base'
+require 'sinatra/reloader'
+
+module FactorySeeder
+  class WebInterface < Sinatra::Base
+    configure do
+      set :public_folder, File.join(File.dirname(__FILE__), '..', '..', 'public')
+      set :views, File.join(File.dirname(__FILE__), '..', '..', 'views')
+      enable :reloader
+      set :bind, '0.0.0.0'
+    end
+
+    before do
+      FactorySeeder.reload!
+    end
+
+    get '/' do
+      @factories = FactorySeeder.scan_factories
+      erb :index
+    end
+
+    get '/factory/:name' do
+      @factory_name = params[:name]
+      @factories = FactorySeeder.scan_factories
+      @factory = @factories[@factory_name]
+
+      if @factory
+        erb :factory_detail
+      else
+        status 404
+        'Factory not found'
+      end
+    end
+
+    post '/generate' do
+      content_type :json
+
+      # Parse JSON body if present
+      if request.content_type == 'application/json'
+        data = JSON.parse(request.body.read)
+        factory_name = data['factory']
+        count = data['count'].to_i
+        traits = data['traits']
+        attributes = data['attributes'] || {}
+      else
+        factory_name = params[:factory]
+        count = params[:count].to_i
+        traits = params[:traits]
+        attributes = params[:attributes] || {}
+      end
+
+      # Parse traits if it's a string
+      traits = if traits.is_a?(String) && !traits.empty?
+                 traits.split(',').map(&:strip)
+               elsif traits.is_a?(Array)
+                 traits.flatten.map(&:strip)
+               else
+                 []
+               end
+
+      begin
+        generator = SeedGenerator.new
+        result = generator.generate(factory_name, count, traits, attributes)
+
+        if result[:errors].any?
+          { success: false, error: result[:errors].join(', ') }.to_json
+        else
+          { success: true, message: "Created #{result[:count]} #{factory_name} records" }.to_json
+        end
+      rescue StandardError => e
+        { success: false, error: e.message }.to_json
+      end
+    end
+
+    get '/api/factories' do
+      content_type :json
+      FactorySeeder.scan_factories.to_json
+    end
+
+    get '/api/factory/:name/preview' do
+      content_type :json
+
+      factory_name = params[:name]
+      traits = params[:traits]
+      attributes = params[:attributes] || {}
+
+      # Parse traits if it's a string
+      traits = if traits.is_a?(String)
+                 traits.split(',').map(&:strip).map(&:to_sym)
+               elsif traits.is_a?(Array)
+                 traits.flatten.map(&:strip).map(&:to_sym)
+               else
+                 []
+               end
+
+      # Parse attributes if it's a string
+      if attributes.is_a?(String) && !attributes.empty?
+        begin
+          attributes = JSON.parse(attributes)
+        rescue JSON::ParserError
+          attributes = {}
+        end
+      end
+
+      begin
+        sample = FactoryBot.build(factory_name, *traits, attributes)
+
+        {
+          success: true,
+          attributes: sample.attributes.reject { |k, _| %w[id created_at updated_at].include?(k) }
+        }.to_json
+      rescue StandardError => e
+        { success: false, error: e.message }.to_json
+      end
+    end
+  end
+end