yoker 0.1.0

data/lib/yoker/cli/init.rb

@@ -0,0 +1,193 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "../generators/base_generator"
+
+module Yoker
+  module CLI
+    class Init < Base
+      desc "generate", "Generate development environment setup"
+
+      option :database,
+             type: :string,
+             enum: %w[postgresql mysql sqlite3],
+             desc: "Database adapter to use"
+
+      option :version_manager,
+             type: :string,
+             enum: %w[mise rbenv rvm none],
+             desc: "Ruby version manager to use"
+
+      option :container,
+             type: :string,
+             enum: %w[docker-compose docker none],
+             desc: "Containerization approach"
+
+      option :ruby_version,
+             type: :string,
+             desc: "Ruby version to use"
+
+      option :interactive,
+             type: :boolean,
+             default: false,
+             aliases: %w[-i],
+             desc: "Run in interactive mode"
+
+      option :force,
+             type: :boolean,
+             default: false,
+             aliases: %w[-f],
+             desc: "Overwrite existing files"
+
+      def generate
+        detect_rails_app!
+
+        info "Setting up development environment for Rails application: #{current_directory_name}"
+
+        config = build_configuration
+
+        info "Configuration:"
+        display_configuration(config)
+
+        return if !options[:force] && !prompt.yes?("Continue with this configuration?")
+
+        spinner = spinner("Generating development setup files...")
+        spinner.auto_spin
+
+        begin
+          generator = Generators::BaseGenerator.new(config, self)
+          generator.generate_all
+
+          spinner.success("✅ Development setup complete!")
+
+          display_next_steps(config)
+        rescue StandardError => e
+          spinner.error("❌ Setup failed: #{e.message}")
+          puts e.backtrace.join("\n") if ENV["DEBUG"]
+          raise
+        end
+      end
+
+      private
+
+      def build_configuration
+        config = {}
+
+        config = if options[:interactive]
+                   interactive_configuration
+                 else
+                   options_configuration
+                 end
+
+        # Fill in detected or default values
+        config[:app_name] ||= sanitize_name(current_directory_name)
+        config[:ruby_version] ||= RUBY_VERSION
+        config[:database] ||= detect_database
+        config[:version_manager] ||= detect_version_manager
+        config[:container] ||= detect_container_preference
+
+        config
+      end
+
+      def interactive_configuration
+        config = {}
+
+        config[:database] = prompt.select(
+          "Which database would you like to use?",
+          %w[postgresql mysql sqlite3],
+          default: detect_database
+        )
+
+        config[:version_manager] = prompt.select(
+          "Which Ruby version manager are you using?",
+          %w[mise rbenv rvm none],
+          default: detect_version_manager
+        )
+
+        config[:container] = prompt.select(
+          "How would you like to handle containerization?",
+          {
+            "Docker Compose (recommended)" => "docker-compose",
+            "Standalone Docker" => "docker",
+            "No containers" => "none"
+          }
+        )
+
+        config[:ruby_version] = prompt.ask(
+          "Ruby version to use?",
+          default: RUBY_VERSION
+        )
+
+        if config[:database] != "sqlite3"
+          config[:additional_services] = prompt.multi_select(
+            "Additional services to include?",
+            %w[redis sidekiq mailcatcher],
+            default: []
+          )
+        end
+
+        config
+      end
+
+      def options_configuration
+        {
+          database: options[:database],
+          version_manager: options[:version_manager],
+          container: options[:container],
+          ruby_version: options[:ruby_version]
+        }.compact
+      end
+
+      def detect_database
+        Detectors::DatabaseDetector.detect || "postgresql"
+      end
+
+      def detect_version_manager
+        Detectors::VersionManagerDetector.detect || "mise"
+      end
+
+      def detect_container_preference
+        return "docker-compose" if File.exist?("docker-compose.yml")
+        return "docker" if File.exist?("Dockerfile")
+
+        "docker-compose"
+      end
+
+      def display_configuration(config)
+        puts ""
+        puts pastel.cyan("  App name: ") + config[:app_name]
+        puts pastel.cyan("  Database: ") + config[:database]
+        puts pastel.cyan("  Ruby version: ") + config[:ruby_version]
+        puts pastel.cyan("  Version manager: ") + config[:version_manager]
+        puts pastel.cyan("  Containerization: ") + config[:container]
+
+        if config[:additional_services]&.any?
+          puts pastel.cyan("  Additional services: ") + config[:additional_services].join(", ")
+        end
+        puts ""
+      end
+
+      def display_next_steps(config)
+        puts ""
+        puts pastel.bright_green("🎉 Setup complete!")
+        puts ""
+        puts "Next steps:"
+        puts "1. Review the generated files"
+        puts "2. Run #{pastel.cyan("chmod +x bin/setup")} to make setup executable"
+        puts "3. Run #{pastel.cyan("./bin/setup")} to initialize your development environment"
+
+        if (config[:container] != "none") && (config[:container] == "docker-compose")
+          puts "4. Use #{pastel.cyan("docker compose up -d")} to start services"
+        end
+
+        puts ""
+        puts "Files generated:"
+        puts "• bin/setup - Enhanced setup script"
+        puts "• config/database.yml - Database configuration" if config[:database] != "sqlite3"
+        puts "• docker-compose.yml - Container orchestration" if config[:container] == "docker-compose"
+        puts "• Dockerfile - Container definition" if config[:container] != "none"
+        puts "• mise.toml - Version manager configuration" if config[:version_manager] == "mise"
+      end
+    end
+  end
+end

data/lib/yoker/cli/update.rb

@@ -0,0 +1,457 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "../generators/base_generator"
+
+module Yoker
+  module CLI
+    class Update < Base
+      desc "run", "Update existing development environment setup"
+
+      option :database,
+             type: :string,
+             enum: %w[postgresql mysql sqlite3],
+             desc: "Change database adapter"
+
+      option :version_manager,
+             type: :string,
+             enum: %w[mise rbenv rvm none],
+             desc: "Change Ruby version manager"
+
+      option :container,
+             type: :string,
+             enum: %w[docker-compose docker none],
+             desc: "Change containerization approach"
+
+      option :ruby_version,
+             type: :string,
+             desc: "Update Ruby version"
+
+      option :add_service,
+             type: :array,
+             enum: %w[redis sidekiq mailcatcher],
+             desc: "Add additional services"
+
+      option :remove_service,
+             type: :array,
+             enum: %w[redis sidekiq mailcatcher],
+             desc: "Remove services"
+
+      option :interactive,
+             type: :boolean,
+             default: false,
+             aliases: %w[-i],
+             desc: "Run in interactive mode"
+
+      option :backup,
+             type: :boolean,
+             default: true,
+             desc: "Backup existing files before updating"
+
+      option :dry_run,
+             type: :boolean,
+             default: false,
+             desc: "Show what would be changed without making changes"
+
+      def execute
+        detect_rails_app!
+
+        info "Updating development environment for Rails application: #{current_directory_name}"
+
+        current_config = detect_current_configuration
+        new_config = build_updated_configuration(current_config)
+
+        if configs_identical?(current_config, new_config)
+          success "No changes detected. Environment is up to date!"
+          return
+        end
+
+        display_configuration_changes(current_config, new_config)
+
+        if options[:dry_run]
+          info "Dry run mode - no changes made"
+          return
+        end
+
+        unless prompt.yes?("Apply these changes?")
+          info "Update cancelled"
+          return
+        end
+
+        perform_update(current_config, new_config)
+      end
+
+      private
+
+      def detect_current_configuration
+        config = {
+          app_name: sanitize_name(current_directory_name),
+          ruby_version: detect_current_ruby_version,
+          database: detect_current_database,
+          version_manager: detect_current_version_manager,
+          container: detect_current_container_setup,
+          additional_services: detect_current_services
+        }
+
+        info "Detected current configuration:"
+        display_simple_config(config)
+
+        config
+      end
+
+      def build_updated_configuration(current_config)
+        if options[:interactive]
+          interactive_update(current_config)
+        else
+          options_update(current_config)
+        end
+      end
+
+      def interactive_update(current_config)
+        new_config = current_config.dup
+
+        # Database update
+        if prompt.yes?("Change database adapter? (currently: #{current_config[:database]})")
+          new_config[:database] = prompt.select(
+            "Select new database:",
+            %w[postgresql mysql sqlite3],
+            default: current_config[:database]
+          )
+        end
+
+        # Version manager update
+        if prompt.yes?("Change version manager? (currently: #{current_config[:version_manager]})")
+          new_config[:version_manager] = prompt.select(
+            "Select version manager:",
+            %w[mise rbenv rvm none],
+            default: current_config[:version_manager]
+          )
+        end
+
+        # Container setup update
+        if prompt.yes?("Change containerization? (currently: #{current_config[:container]})")
+          new_config[:container] = prompt.select(
+            "Select containerization approach:",
+            {
+              "Docker Compose" => "docker-compose",
+              "Standalone Docker" => "docker",
+              "No containers" => "none"
+            },
+            default: current_config[:container]
+          )
+        end
+
+        # Ruby version update
+        if prompt.yes?("Update Ruby version? (currently: #{current_config[:ruby_version]})")
+          new_config[:ruby_version] = prompt.ask(
+            "Enter Ruby version:",
+            default: current_config[:ruby_version]
+          )
+        end
+
+        # Services update
+        if prompt.yes?("Modify additional services?")
+          current_services = current_config[:additional_services] || []
+          new_config[:additional_services] = prompt.multi_select(
+            "Select services:",
+            %w[redis sidekiq mailcatcher],
+            default: current_services
+          )
+        end
+
+        new_config
+      end
+
+      def options_update(current_config)
+        new_config = current_config.dup
+
+        # Apply command line options
+        new_config[:database] = options[:database] if options[:database]
+        new_config[:version_manager] = options[:version_manager] if options[:version_manager]
+        new_config[:container] = options[:container] if options[:container]
+        new_config[:ruby_version] = options[:ruby_version] if options[:ruby_version]
+
+        # Handle service additions/removals
+        if options[:add_service] || options[:remove_service]
+          services = Set.new(current_config[:additional_services] || [])
+
+          services.merge(options[:add_service]) if options[:add_service]
+
+          services.subtract(options[:remove_service]) if options[:remove_service]
+
+          new_config[:additional_services] = services.to_a
+        end
+
+        new_config
+      end
+
+      def perform_update(current_config, new_config)
+        backup_existing_files if options[:backup]
+
+        spinner = spinner("Updating development environment...")
+        spinner.auto_spin
+
+        begin
+          # Handle major changes that require cleanup
+          handle_container_migration(current_config, new_config)
+          handle_database_migration(current_config, new_config)
+          handle_version_manager_migration(current_config, new_config)
+
+          # Generate updated configuration
+          generator = Generators::BaseGenerator.new(new_config, self)
+          generator.generate_all
+
+          # Update existing services
+          update_running_services(current_config, new_config)
+
+          spinner.success("✅ Environment updated successfully!")
+
+          display_post_update_instructions(current_config, new_config)
+        rescue StandardError => e
+          spinner.error("❌ Update failed: #{e.message}")
+          offer_rollback if options[:backup]
+          raise
+        end
+      end
+
+      def handle_container_migration(old_config, new_config)
+        return if old_config[:container] == new_config[:container]
+
+        info "Migrating containerization from #{old_config[:container]} to #{new_config[:container]}"
+
+        case [old_config[:container], new_config[:container]]
+        when %w[docker-compose docker]
+          migrate_compose_to_docker
+        when %w[docker-compose none]
+          migrate_compose_to_native
+        when %w[docker docker-compose]
+          migrate_docker_to_compose
+        when %w[docker none]
+          migrate_docker_to_native
+        when %w[none docker-compose]
+          migrate_native_to_compose
+        when %w[none docker]
+          migrate_native_to_docker
+        end
+      end
+
+      def handle_database_migration(old_config, new_config)
+        return if old_config[:database] == new_config[:database]
+
+        warning "Database change detected: #{old_config[:database]} → #{new_config[:database]}"
+        warning "You will need to migrate your data manually"
+
+        info "Steps to migrate your database:"
+        puts "1. Export data from #{old_config[:database]}"
+        puts "2. Run './bin/setup' to initialize #{new_config[:database]}"
+        puts "3. Import your data to the new database"
+      end
+
+      def handle_version_manager_migration(old_config, new_config)
+        return if old_config[:version_manager] == new_config[:version_manager]
+
+        info "Migrating version manager: #{old_config[:version_manager]} → #{new_config[:version_manager]}"
+
+        # Clean up old version manager files
+        cleanup_version_manager_files(old_config[:version_manager])
+      end
+
+      def cleanup_version_manager_files(old_manager)
+        files_to_remove = case old_manager
+                          when "mise"
+                            %w[mise.toml .mise.local.toml]
+                          when "rbenv"
+                            %w[.ruby-version]
+                          when "rvm"
+                            %w[.rvmrc]
+                          end
+
+        files_to_remove&.each do |file|
+          if File.exist?(file)
+            info "Removing #{file}"
+            File.delete(file) unless options[:dry_run]
+          end
+        end
+      end
+
+      def update_running_services(old_config, new_config)
+        return unless old_config[:container] != "none" && new_config[:container] != "none"
+
+        # Stop old services
+        stop_services(old_config)
+
+        # Start new services
+        start_services(new_config)
+      end
+
+      def stop_services(config)
+        case config[:container]
+        when "docker-compose"
+          system("docker compose down", exception: false) if File.exist?("docker-compose.yml")
+        when "docker"
+          stop_standalone_containers(config)
+        end
+      end
+
+      def start_services(config)
+        info "Starting services with new configuration..."
+        system("./bin/setup", exception: false) if File.exist?("bin/setup")
+      end
+
+      def stop_standalone_containers(config)
+        container_name = "#{config[:app_name]}_#{config[:database]}"
+        system("docker stop #{container_name}", exception: false)
+
+        return unless config[:additional_services]&.include?("redis")
+
+        redis_container = "#{config[:app_name]}_redis"
+        system("docker stop #{redis_container}", exception: false)
+      end
+
+      def backup_existing_files
+        timestamp = Time.now.strftime("%Y%m%d_%H%M%S")
+        backup_dir = "backup_#{timestamp}"
+
+        info "Creating backup in #{backup_dir}/"
+        Dir.mkdir(backup_dir)
+
+        files_to_backup.each do |file|
+          if File.exist?(file)
+            backup_path = File.join(backup_dir, file.gsub("/", "_"))
+            FileUtils.cp(file, backup_path)
+          end
+        end
+      end
+
+      def files_to_backup
+        %w[
+          bin/setup
+          config/database.yml
+          docker-compose.yml
+          Dockerfile
+          mise.toml
+          .ruby-version
+          .tool-versions
+          Procfile.dev
+        ]
+      end
+
+      def offer_rollback
+        return unless prompt.yes?("Restore from backup?")
+
+        # Implementation for rollback would go here
+        info "Rollback functionality coming soon"
+      end
+
+      def configs_identical?(config1, config2)
+        config1.to_s == config2.to_s
+      end
+
+      def display_configuration_changes(old_config, new_config)
+        puts ""
+        puts pastel.bright_blue("Configuration Changes:")
+        puts ""
+
+        old_config.each do |key, old_value|
+          new_value = new_config[key]
+          next if old_value == new_value
+
+          puts "  #{pastel.cyan(key.to_s)}:"
+          puts "    #{pastel.red("- #{old_value}")}"
+          puts "    #{pastel.green("+ #{new_value}")}"
+        end
+        puts ""
+      end
+
+      def display_simple_config(config)
+        config.each do |key, value|
+          puts "  #{pastel.cyan(key)}: #{value}"
+        end
+        puts ""
+      end
+
+      def display_post_update_instructions(old_config, new_config)
+        puts ""
+        puts pastel.bright_green("🎉 Update complete!")
+        puts ""
+        puts "Next steps:"
+        puts "1. Review the updated configuration files"
+        puts "2. Run #{pastel.cyan("./bin/setup")} to apply changes"
+
+        if old_config[:database] != new_config[:database]
+          puts "3. #{pastel.yellow("Important:")} Migrate your database data manually"
+        end
+
+        return unless old_config[:container] != new_config[:container]
+
+        puts "4. Update your development workflow for the new container setup"
+      end
+
+      # Detection methods
+      def detect_current_ruby_version
+        Detectors::VersionManagerDetector.ruby_version_from_file || RUBY_VERSION
+      end
+
+      def detect_current_database
+        Detectors::DatabaseDetector.detect || "sqlite3"
+      end
+
+      def detect_current_version_manager
+        Detectors::VersionManagerDetector.detect || "none"
+      end
+
+      def detect_current_container_setup
+        return "docker-compose" if File.exist?("docker-compose.yml")
+        return "docker" if File.exist?("Dockerfile") && !File.exist?("docker-compose.yml")
+
+        "none"
+      end
+
+      def detect_current_services
+        services = []
+
+        if File.exist?("docker-compose.yml")
+          compose_content = File.read("docker-compose.yml")
+          services << "redis" if compose_content.include?("redis:")
+          services << "sidekiq" if compose_content.include?("sidekiq:")
+          services << "mailcatcher" if compose_content.include?("mailcatcher")
+        end
+
+        services << "sidekiq" if File.exist?("config/sidekiq.yml") && !services.include?("sidekiq")
+
+        services
+      end
+
+      # Container migration methods
+      def migrate_compose_to_docker
+        info "Migrating from Docker Compose to standalone Docker"
+        system("docker compose down", exception: false) if File.exist?("docker-compose.yml")
+      end
+
+      def migrate_compose_to_native
+        info "Migrating from Docker Compose to native setup"
+        system("docker compose down", exception: false) if File.exist?("docker-compose.yml")
+      end
+
+      def migrate_docker_to_compose
+        info "Migrating from standalone Docker to Docker Compose"
+        # Stop existing containers
+      end
+
+      def migrate_docker_to_native
+        info "Migrating from standalone Docker to native setup"
+        # Stop existing containers
+      end
+
+      def migrate_native_to_compose
+        info "Migrating from native setup to Docker Compose"
+        # Stop native services if possible
+      end
+
+      def migrate_native_to_docker
+        info "Migrating from native setup to standalone Docker"
+        # Stop native services if possible
+      end
+    end
+  end
+end