yoker 0.1.0

data/lib/yoker/generators/container/none.rb

@@ -0,0 +1,314 @@
+# frozen_string_literal: true
+
+module Yoker
+  module Generators
+    module Container
+      class None
+        attr_reader :config, :shell
+
+        def initialize(config, shell)
+          @config = config
+          @shell = shell
+        end
+
+        def generate
+          generate_native_setup_instructions
+          generate_database_setup_scripts if needs_database_setup?
+          generate_service_setup_scripts if needs_service_setup?
+          create_development_procfile if needs_procfile?
+        end
+
+        private
+
+        def generate_native_setup_instructions
+          shell.template(
+            "native/SETUP_INSTRUCTIONS.md.erb",
+            "SETUP_INSTRUCTIONS.md",
+            {
+              app_name: config[:app_name],
+              database: config[:database],
+              version_manager: config[:version_manager],
+              ruby_version: config[:ruby_version],
+              additional_services: config[:additional_services] || [],
+              installation_commands: installation_commands,
+              service_commands: service_commands
+            }
+          )
+        end
+
+        def generate_database_setup_scripts
+          case config[:database]
+          when "postgresql"
+            generate_postgresql_setup
+          when "mysql"
+            generate_mysql_setup
+          end
+        end
+
+        def generate_postgresql_setup
+          shell.template(
+            "native/postgresql-setup.sh.erb",
+            "bin/postgresql-setup",
+            {
+              app_name: config[:app_name],
+              version_manager: config[:version_manager]
+            }
+          )
+
+          File.chmod(0o755, "bin/postgresql-setup") if File.exist?("bin/postgresql-setup")
+        end
+
+        def generate_mysql_setup
+          shell.template(
+            "native/mysql-setup.sh.erb",
+            "bin/mysql-setup",
+            {
+              app_name: config[:app_name],
+              version_manager: config[:version_manager]
+            }
+          )
+
+          File.chmod(0o755, "bin/mysql-setup") if File.exist?("bin/mysql-setup")
+        end
+
+        def generate_service_setup_scripts
+          generate_redis_setup if config[:additional_services]&.include?("redis")
+
+          return unless config[:additional_services]&.include?("sidekiq")
+
+          generate_sidekiq_setup
+        end
+
+        def generate_redis_setup
+          shell.template(
+            "native/redis-setup.sh.erb",
+            "bin/redis-setup",
+            {
+              version_manager: config[:version_manager]
+            }
+          )
+
+          File.chmod(0o755, "bin/redis-setup") if File.exist?("bin/redis-setup")
+        end
+
+        def generate_sidekiq_setup
+          shell.template(
+            "native/sidekiq.yml.erb",
+            "config/sidekiq.yml",
+            {
+              app_name: config[:app_name]
+            }
+          )
+        end
+
+        def create_development_procfile
+          services = ["web: bundle exec rails server -b 0.0.0.0 -p 3000"]
+
+          services << "sidekiq: bundle exec sidekiq" if config[:additional_services]&.include?("sidekiq")
+
+          shell.create_file("Procfile.dev", services.join("\n"))
+        end
+
+        def installation_commands
+          {
+            "homebrew_packages" => homebrew_packages,
+            "apt_packages" => apt_packages,
+            "database_commands" => database_installation_commands,
+            "service_commands" => service_installation_commands
+          }
+        end
+
+        def homebrew_packages
+          packages = []
+
+          case config[:database]
+          when "postgresql"
+            packages << "postgresql@16"
+          when "mysql"
+            packages << "mysql@8.0"
+          end
+
+          packages << "redis" if config[:additional_services]&.include?("redis")
+
+          packages
+        end
+
+        def apt_packages
+          packages = []
+
+          case config[:database]
+          when "postgresql"
+            packages << "postgresql" << "postgresql-contrib" << "libpq-dev"
+          when "mysql"
+            packages << "mysql-server" << "libmysqlclient-dev"
+          end
+
+          packages << "redis-server" if config[:additional_services]&.include?("redis")
+
+          packages
+        end
+
+        def database_installation_commands
+          commands = {}
+
+          case config[:database]
+          when "postgresql"
+            commands["macos"] = [
+              "brew install postgresql@16",
+              "brew services start postgresql@16",
+              "createdb #{config[:app_name]}_development",
+              "createdb #{config[:app_name]}_test"
+            ]
+            commands["ubuntu"] = [
+              "sudo apt update",
+              "sudo apt install -y postgresql postgresql-contrib libpq-dev",
+              "sudo systemctl start postgresql",
+              "sudo systemctl enable postgresql",
+              "sudo -u postgres createuser -s $USER",
+              "createdb #{config[:app_name]}_development",
+              "createdb #{config[:app_name]}_test"
+            ]
+          when "mysql"
+            commands["macos"] = [
+              "brew install mysql@8.0",
+              "brew services start mysql@8.0",
+              "mysql -u root -e \"CREATE DATABASE #{config[:app_name]}_development;\"",
+              "mysql -u root -e \"CREATE DATABASE #{config[:app_name]}_test;\""
+            ]
+            commands["ubuntu"] = [
+              "sudo apt update",
+              "sudo apt install -y mysql-server libmysqlclient-dev",
+              "sudo systemctl start mysql",
+              "sudo systemctl enable mysql",
+              "sudo mysql -e \"CREATE DATABASE #{config[:app_name]}_development;\"",
+              "sudo mysql -e \"CREATE DATABASE #{config[:app_name]}_test;\""
+            ]
+          end
+
+          commands
+        end
+
+        def service_installation_commands
+          commands = {}
+
+          if config[:additional_services]&.include?("redis")
+            commands["redis"] = {
+              "macos" => [
+                "brew install redis",
+                "brew services start redis"
+              ],
+              "ubuntu" => [
+                "sudo apt install -y redis-server",
+                "sudo systemctl start redis-server",
+                "sudo systemctl enable redis-server"
+              ]
+            }
+          end
+
+          commands
+        end
+
+        def service_commands
+          commands = {}
+
+          case config[:database]
+          when "postgresql"
+            commands["postgresql"] = {
+              "start" => service_start_command("postgresql"),
+              "stop" => service_stop_command("postgresql"),
+              "status" => service_status_command("postgresql")
+            }
+          when "mysql"
+            commands["mysql"] = {
+              "start" => service_start_command("mysql"),
+              "stop" => service_stop_command("mysql"),
+              "status" => service_status_command("mysql")
+            }
+          end
+
+          if config[:additional_services]&.include?("redis")
+            commands["redis"] = {
+              "start" => service_start_command("redis"),
+              "stop" => service_stop_command("redis"),
+              "status" => service_status_command("redis")
+            }
+          end
+
+          commands
+        end
+
+        def service_start_command(service)
+          case service
+          when "postgresql"
+            {
+              "macos" => "brew services start postgresql@16",
+              "ubuntu" => "sudo systemctl start postgresql"
+            }
+          when "mysql"
+            {
+              "macos" => "brew services start mysql@8.0",
+              "ubuntu" => "sudo systemctl start mysql"
+            }
+          when "redis"
+            {
+              "macos" => "brew services start redis",
+              "ubuntu" => "sudo systemctl start redis-server"
+            }
+          end
+        end
+
+        def service_stop_command(service)
+          case service
+          when "postgresql"
+            {
+              "macos" => "brew services stop postgresql@16",
+              "ubuntu" => "sudo systemctl stop postgresql"
+            }
+          when "mysql"
+            {
+              "macos" => "brew services stop mysql@8.0",
+              "ubuntu" => "sudo systemctl stop mysql"
+            }
+          when "redis"
+            {
+              "macos" => "brew services stop redis",
+              "ubuntu" => "sudo systemctl stop redis-server"
+            }
+          end
+        end
+
+        def service_status_command(service)
+          case service
+          when "postgresql"
+            {
+              "macos" => "brew services list | grep postgresql",
+              "ubuntu" => "sudo systemctl status postgresql"
+            }
+          when "mysql"
+            {
+              "macos" => "brew services list | grep mysql",
+              "ubuntu" => "sudo systemctl status mysql"
+            }
+          when "redis"
+            {
+              "macos" => "brew services list | grep redis",
+              "ubuntu" => "sudo systemctl status redis-server"
+            }
+          end
+        end
+
+        def needs_database_setup?
+          config[:database] != "sqlite3"
+        end
+
+        def needs_service_setup?
+          config[:additional_services]&.any?
+        end
+
+        def needs_procfile?
+          config[:additional_services]&.include?("sidekiq") || config[:database] != "sqlite3"
+        end
+      end
+    end
+  end
+end

data/lib/yoker/generators/database/mysql.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+module Yoker
+  module Generators
+    module Database
+      class Mysql
+        attr_reader :config, :shell
+
+        def initialize(config, shell)
+          @config = config
+          @shell = shell
+        end
+
+        def generate
+          generate_database_yml
+          generate_init_sql if config[:container] != "none"
+          generate_mysql_config if needs_custom_config?
+        end
+
+        private
+
+        def generate_database_yml
+          shell.template(
+            "config/database_mysql.yml.erb",
+            "config/database.yml",
+            {
+              app_name: config[:app_name],
+              username: database_username,
+              password: database_password,
+              host: database_host,
+              port: database_port,
+              socket: database_socket,
+              encoding: database_encoding
+            }
+          )
+        end
+
+        def generate_init_sql
+          shell.template(
+            "docker/init_mysql.sql.erb",
+            "docker/init.sql",
+            {
+              app_name: config[:app_name],
+              username: database_username,
+              password: database_password,
+              root_password: root_password
+            }
+          )
+        end
+
+        def generate_mysql_config
+          shell.template(
+            "config/mysql.cnf.erb",
+            "config/mysql.cnf",
+            mysql_config_options
+          )
+        end
+
+        def database_username
+          case config[:container]
+          when "none"
+            ENV["USER"] || "root"
+          else
+            "rails"
+          end
+        end
+
+        def database_password
+          case config[:container]
+          when "none"
+            # For native setup, often no password or user-specific
+            ""
+          else
+            "password"
+          end
+        end
+
+        def root_password
+          config[:container] == "none" ? "" : "password"
+        end
+
+        def database_host
+          case config[:container]
+          when "none"
+            "localhost"
+          when "docker-compose"
+            "db"
+          else
+            "localhost"
+          end
+        end
+
+        def database_port
+          3306
+        end
+
+        def database_socket
+          # MySQL socket path varies by system
+          case config[:container]
+          when "none"
+            detect_mysql_socket
+          else
+            nil # Not needed for containerized setup
+          end
+        end
+
+        def database_encoding
+          "utf8mb4"
+        end
+
+        def detect_mysql_socket
+          possible_sockets = [
+            "/tmp/mysql.sock",                    # macOS default
+            "/var/run/mysqld/mysqld.sock",        # Ubuntu default
+            "/var/lib/mysql/mysql.sock",          # CentOS/RHEL
+            "/opt/homebrew/var/mysql/mysql.sock", # Homebrew on Apple Silicon
+            "/usr/local/var/mysql/mysql.sock"     # Homebrew on Intel
+          ]
+
+          possible_sockets.find { |socket| File.exist?(socket) }
+        end
+
+        def mysql_config_options
+          {
+            max_connections: 200,
+            innodb_buffer_pool_size: "256M",
+            innodb_log_file_size: "64M",
+            query_cache_size: "32M",
+            tmp_table_size: "64M",
+            max_heap_table_size: "64M",
+            slow_query_log: development_mode?,
+            general_log: development_mode? && config[:verbose]
+          }
+        end
+
+        def development_mode?
+          true # Always true for development setup
+        end
+
+        def needs_custom_config?
+          # Generate custom MySQL config for performance tuning in development
+          config[:container] != "none" || config[:additional_services]&.any?
+        end
+      end
+    end
+  end
+end

data/lib/yoker/generators/database/postgresql.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Yoker
+  module Generators
+    module Database
+      class Postgresql
+        attr_reader :config, :shell
+
+        def initialize(config, shell)
+          @config = config
+          @shell = shell
+        end
+
+        def generate
+          generate_database_yml
+          generate_init_sql if config[:container] != "none"
+        end
+
+        private
+
+        def generate_database_yml
+          shell.template(
+            "config/database_postgresql.yml.erb",
+            "config/database.yml",
+            {
+              app_name: config[:app_name],
+              username: database_username,
+              password: database_password,
+              host: database_host,
+              port: database_port
+            }
+          )
+        end
+
+        def generate_init_sql
+          shell.template(
+            "docker/init_postgresql.sql.erb",
+            "docker/init.sql",
+            {
+              app_name: config[:app_name],
+              username: database_username
+            }
+          )
+        end
+
+        def database_username
+          config[:container] == "none" ? ENV["USER"] || "postgres" : "postgres"
+        end
+
+        def database_password
+          config[:container] == "none" ? "" : "password"
+        end
+
+        def database_host
+          config[:container] == "none" ? "localhost" : "db"
+        end
+
+        def database_port
+          5432
+        end
+      end
+    end
+  end
+end

data/lib/yoker/generators/database/sqlite.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module Yoker
+  module Generators
+    module Database
+      class Sqlite
+        attr_reader :config, :shell
+
+        def initialize(config, shell)
+          @config = config
+          @shell = shell
+        end
+
+        def generate
+          generate_database_yml
+          generate_sqlite_optimizations if needs_optimizations?
+          create_database_directory
+          generate_backup_script if config[:backup_existing]
+        end
+
+        private
+
+        def generate_database_yml
+          shell.template(
+            "config/database_sqlite.yml.erb",
+            "config/database.yml",
+            {
+              app_name: config[:app_name],
+              database_path: database_path,
+              timeout: database_timeout,
+              pool_size: database_pool_size,
+              pragmas: sqlite_pragmas
+            }
+          )
+        end
+
+        def generate_sqlite_optimizations
+          shell.template(
+            "config/sqlite_optimizations.rb.erb",
+            "config/initializers/sqlite_optimizations.rb",
+            {
+              pragmas: sqlite_performance_pragmas,
+              development_mode: true
+            }
+          )
+        end
+
+        def create_database_directory
+          db_dir = File.dirname(database_path_full)
+          Dir.mkdir(db_dir) unless Dir.exist?(db_dir)
+
+          # Create .gitkeep for empty db directory
+          gitkeep_path = File.join(db_dir, ".gitkeep")
+          File.write(gitkeep_path, "") unless File.exist?(gitkeep_path)
+        end
+
+        def generate_backup_script
+          shell.template(
+            "scripts/sqlite_backup.sh.erb",
+            "bin/sqlite-backup",
+            {
+              app_name: config[:app_name],
+              database_path: database_path_full,
+              backup_directory: "db/backups"
+            }
+          )
+
+          # Make executable
+          File.chmod(0o755, "bin/sqlite-backup") if File.exist?("bin/sqlite-backup")
+        end
+
+        def database_path
+          "db/#{config[:app_name]}_development.sqlite3"
+        end
+
+        def database_path_full
+          File.join(Dir.pwd, database_path)
+        end
+
+        def database_timeout
+          5000 # 5 seconds
+        end
+
+        def database_pool_size
+          # SQLite doesn't benefit from large connection pools
+          ENV.fetch("RAILS_MAX_THREADS", 5).to_i
+        end
+
+        def sqlite_pragmas
+          {
+            # Basic pragmas for development
+            "journal_mode" => "WAL",
+            "synchronous" => "NORMAL",
+            "cache_size" => "-64000", # 64MB cache
+            "temp_store" => "memory",
+            "mmap_size" => "268435456" # 256MB mmap
+          }
+        end
+
+        def sqlite_performance_pragmas
+          {
+            # Performance-focused pragmas for development
+            "journal_mode" => "WAL",
+            "synchronous" => "NORMAL",
+            "cache_size" => "-64000",
+            "temp_store" => "memory",
+            "mmap_size" => "268435456",
+            "page_size" => "4096",
+            "auto_vacuum" => "INCREMENTAL",
+            "wal_autocheckpoint" => "1000",
+            "optimize" => nil # Run PRAGMA optimize on connection
+          }
+        end
+
+        def needs_optimizations?
+          # Always generate optimizations for development
+          # SQLite can benefit significantly from proper PRAGMA settings
+          true
+        end
+      end
+    end
+  end
+end