yoker 0.1.0

data/lib/yoker/generators/base_generator.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require_relative "database/postgresql"
+require_relative "database/mysql"
+require_relative "database/sqlite"
+require_relative "version_manager/mise"
+require_relative "version_manager/rbenv"
+require_relative "container/docker_compose"
+require_relative "container/docker"
+
+module Yoker
+  module Generators
+    class BaseGenerator
+      attr_reader :config, :shell
+
+      def initialize(config, shell)
+        @config = config
+        @shell = shell
+      end
+
+      def generate_all
+        generate_version_manager_files
+        generate_database_files
+        generate_container_files
+        generate_setup_script
+        update_gemfile if config[:database] != "sqlite3"
+      end
+
+      private
+
+      def generate_version_manager_files
+        case config[:version_manager]
+        when "mise"
+          VersionManager::Mise.new(config, shell).generate
+        when "rbenv"
+          VersionManager::Rbenv.new(config, shell).generate
+        end
+      end
+
+      def generate_database_files
+        case config[:database]
+        when "postgresql"
+          Database::Postgresql.new(config, shell).generate
+        when "mysql"
+          Database::Mysql.new(config, shell).generate
+        when "sqlite3"
+          Database::Sqlite.new(config, shell).generate
+        end
+      end
+
+      def generate_container_files
+        case config[:container]
+        when "docker-compose"
+          Container::DockerCompose.new(config, shell).generate
+        when "docker"
+          Container::Docker.new(config, shell).generate
+        when "none"
+          Container::None.new(config, shell).generate
+        end
+      end
+
+      def generate_setup_script
+        shell.template(
+          "bin/setup.rb.erb",
+          "bin/setup",
+          config
+        )
+
+        # Make executable
+        File.chmod(0o755, "bin/setup") if File.exist?("bin/setup")
+      end
+
+      def update_gemfile
+        gemfile_path = "Gemfile"
+        return unless File.exist?(gemfile_path)
+
+        gemfile_content = File.read(gemfile_path)
+
+        # Add database gem if not present
+        db_gem = database_gem_name
+        unless gemfile_content.include?(db_gem)
+          shell.append_to_file(gemfile_path, "\n# Database\ngem '#{db_gem}', '~> 1.1'\n")
+        end
+
+        # Add development gems
+        dev_gems = development_gems
+        dev_gems.each do |gem_name, version|
+          next if gemfile_content.include?(gem_name)
+
+          shell.append_to_file(
+            gemfile_path,
+            "\n# Development\ngem '#{gem_name}', '#{version}', group: :development\n"
+          )
+        end
+      end
+
+      def database_gem_name
+        case config[:database]
+        when "postgresql"
+          "pg"
+        when "mysql"
+          "mysql2"
+        when "sqlite3"
+          "sqlite3"
+        end
+      end
+
+      def development_gems
+        {
+          "debug" => "~> 1.8",
+          "letter_opener" => "~> 1.8"
+        }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,255 @@
+# frozen_string_literal: true
+
+module Yoker
+  module Generators
+    module Container
+      class Docker
+        attr_reader :config, :shell
+
+        def initialize(config, shell)
+          @config = config
+          @shell = shell
+        end
+
+        def generate
+          generate_dockerfile if should_generate_dockerfile?
+          generate_dockerignore
+          generate_docker_scripts
+          generate_network_setup if needs_custom_network?
+        end
+
+        private
+
+        def generate_dockerfile
+          shell.template(
+            "docker/Dockerfile.erb",
+            "Dockerfile",
+            dockerfile_context
+          )
+        end
+
+        def generate_dockerignore
+          shell.template(
+            "docker/dockerignore.erb",
+            ".dockerignore",
+            {}
+          )
+        end
+
+        def generate_docker_scripts
+          # Generate convenience scripts for Docker management
+          generate_docker_dev_script
+          generate_docker_setup_script
+        end
+
+        def generate_docker_dev_script
+          shell.template(
+            "docker/dev.sh.erb",
+            "bin/docker-dev",
+            {
+              app_name: config[:app_name],
+              database: config[:database],
+              additional_services: config[:additional_services] || []
+            }
+          )
+
+          # Make executable
+          File.chmod(0o755, "bin/docker-dev") if File.exist?("bin/docker-dev")
+        end
+
+        def generate_docker_setup_script
+          shell.template(
+            "docker/docker-setup.sh.erb",
+            "bin/docker-setup",
+            docker_setup_context
+          )
+
+          # Make executable
+          File.chmod(0o755, "bin/docker-setup") if File.exist?("bin/docker-setup")
+        end
+
+        def generate_network_setup
+          # Create a custom Docker network for service communication
+          network_name = "#{config[:app_name]}_network"
+
+          shell.create_file(
+            "docker/network-setup.sh",
+            network_setup_script(network_name)
+          )
+
+          File.chmod(0o755, "docker/network-setup.sh") if File.exist?("docker/network-setup.sh")
+        end
+
+        def dockerfile_context
+          {
+            ruby_version: config[:ruby_version],
+            database: config[:database],
+            version_manager: config[:version_manager],
+            additional_packages: dockerfile_packages,
+            app_name: config[:app_name],
+            additional_services: config[:additional_services] || [],
+            needs_custom_entrypoint?: false # Standalone Docker doesn't need complex entrypoint
+          }
+        end
+
+        def docker_setup_context
+          {
+            app_name: config[:app_name],
+            database: config[:database],
+            database_image: database_image,
+            database_environment: database_environment,
+            database_ports: database_ports,
+            database_volumes: database_volumes,
+            database_health_check: database_health_check,
+            additional_containers: additional_containers,
+            network_name: "#{config[:app_name]}_network"
+          }
+        end
+
+        def dockerfile_packages
+          packages = %w[build-base git bash curl tzdata ca-certificates]
+
+          case config[:database]
+          when "postgresql"
+            packages << "postgresql-dev" << "postgresql-client"
+          when "mysql"
+            packages << "mysql-dev" << "mysql-client"
+          end
+
+          # Add Node.js if needed for assets
+          packages << "nodejs" << "npm"
+
+          packages
+        end
+
+        def database_image
+          case config[:database]
+          when "postgresql"
+            "postgres:18-alpine"
+          when "mysql"
+            "mysql:8.0"
+          when "sqlite3"
+            nil # SQLite doesn't need a container
+          end
+        end
+
+        def database_environment
+          case config[:database]
+          when "postgresql"
+            {
+              "POSTGRES_DB" => "#{config[:app_name]}_development",
+              "POSTGRES_USER" => "postgres",
+              "POSTGRES_PASSWORD" => "password"
+            }
+          when "mysql"
+            {
+              "MYSQL_ROOT_PASSWORD" => "password",
+              "MYSQL_DATABASE" => "#{config[:app_name]}_development",
+              "MYSQL_USER" => "rails",
+              "MYSQL_PASSWORD" => "password"
+            }
+          else
+            {}
+          end
+        end
+
+        def database_ports
+          case config[:database]
+          when "postgresql"
+            "5432:5432"
+          when "mysql"
+            "3306:3306"
+          else
+            nil
+          end
+        end
+
+        def database_volumes
+          container_name = "#{config[:app_name]}_#{config[:database]}"
+
+          case config[:database]
+          when "postgresql"
+            [
+              "#{container_name}_data:/var/lib/postgresql/data",
+              "./docker/init.sql:/docker-entrypoint-initdb.d/init.sql:ro"
+            ]
+          when "mysql"
+            [
+              "#{container_name}_data:/var/lib/mysql"
+            ]
+          else
+            []
+          end
+        end
+
+        def database_health_check
+          case config[:database]
+          when "postgresql"
+            "pg_isready -U postgres"
+          when "mysql"
+            "mysqladmin ping -h localhost -u root -ppassword"
+          else
+            nil
+          end
+        end
+
+        def additional_containers
+          containers = []
+
+          if config[:additional_services]&.include?("redis")
+            containers << {
+              name: "#{config[:app_name]}_redis",
+              image: "redis:7-alpine",
+              ports: "6379:6379",
+              volumes: ["#{config[:app_name]}_redis_data:/data"]
+            }
+          end
+
+          if config[:additional_services]&.include?("mailcatcher")
+            containers << {
+              name: "#{config[:app_name]}_mailcatcher",
+              image: "schickling/mailcatcher",
+              ports: "1080:1080 -p 1025:1025"
+            }
+          end
+
+          containers
+        end
+
+        def network_setup_script(network_name)
+          <<~BASH
+            #!/bin/bash
+            # Docker network setup for #{config[:app_name]}
+            # Generated by rails-dev-setup
+
+            set -e
+
+            NETWORK_NAME="#{network_name}"
+
+            echo "Setting up Docker network: $NETWORK_NAME"
+
+            # Create network if it doesn't exist
+            if ! docker network ls | grep -q "$NETWORK_NAME"; then
+              echo "Creating Docker network: $NETWORK_NAME"
+              docker network create "$NETWORK_NAME"
+            else
+              echo "Docker network $NETWORK_NAME already exists"
+            fi
+
+            echo "✅ Network setup complete"
+          BASH
+        end
+
+        def should_generate_dockerfile?
+          # Generate Dockerfile unless it already exists and user doesn't want to overwrite
+          !File.exist?("Dockerfile") || config[:force_overwrite]
+        end
+
+        def needs_custom_network?
+          # Custom network needed when we have multiple services
+          config[:additional_services]&.any? || config[:database] != "sqlite3"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,255 @@
+# frozen_string_literal: true
+
+module Yoker
+  module Generators
+    module Container
+      class DockerCompose
+        attr_reader :config, :shell
+
+        def initialize(config, shell)
+          @config = config
+          @shell = shell
+        end
+
+        def generate
+          generate_compose_file
+          generate_dockerfile
+          generate_dockerignore
+          generate_entrypoint if needs_custom_entrypoint?
+        end
+
+        private
+
+        def generate_compose_file
+          services = base_services
+          services.merge!(additional_services)
+
+          shell.template(
+            "docker/docker-compose.yml.erb",
+            "docker-compose.yml",
+            {
+              services: services,
+              volumes: compose_volumes,
+              networks: compose_networks
+            }
+          )
+        end
+
+        def generate_dockerfile
+          shell.template(
+            "docker/Dockerfile.erb",
+            "Dockerfile",
+            {
+              ruby_version: config[:ruby_version],
+              database: config[:database],
+              version_manager: config[:version_manager],
+              additional_packages: dockerfile_packages
+            }
+          )
+        end
+
+        def generate_dockerignore
+          shell.template(
+            "docker/dockerignore.erb",
+            ".dockerignore",
+            {}
+          )
+        end
+
+        def generate_entrypoint
+          shell.template(
+            "docker/entrypoint.sh.erb",
+            "docker/entrypoint.sh",
+            config
+          )
+
+          File.chmod(0o755, "docker/entrypoint.sh") if File.exist?("docker/entrypoint.sh")
+        end
+
+        def base_services
+          services = {}
+
+          # Database service
+          services[:db] = database_service_config
+
+          # Web service
+          services[:web] = web_service_config
+
+          services
+        end
+
+        def database_service_config
+          case config[:database]
+          when "postgresql"
+            {
+              image: "postgres:18-alpine",
+              environment: {
+                "POSTGRES_DB" => "#{config[:app_name]}_development",
+                "POSTGRES_USER" => "postgres",
+                "POSTGRES_PASSWORD" => "password"
+              },
+              ports: ["5432:5432"],
+              volumes: [
+                "postgres_data:/var/lib/postgresql/data",
+                "./docker/init.sql:/docker-entrypoint-initdb.d/init.sql:ro"
+              ],
+              healthcheck: {
+                test: ["CMD-SHELL", "pg_isready -U postgres"],
+                interval: "10s",
+                timeout: "5s",
+                retries: 5
+              }
+            }
+          when "mysql"
+            {
+              image: "mysql:8.0",
+              environment: {
+                "MYSQL_ROOT_PASSWORD" => "password",
+                "MYSQL_DATABASE" => "#{config[:app_name]}_development",
+                "MYSQL_USER" => "rails",
+                "MYSQL_PASSWORD" => "password"
+              },
+              ports: ["3306:3306"],
+              volumes: [
+                "mysql_data:/var/lib/mysql"
+              ],
+              healthcheck: {
+                test: ["CMD", "mysqladmin", "ping", "-h", "localhost"],
+                interval: "10s",
+                timeout: "5s",
+                retries: 5
+              }
+            }
+          end
+        end
+
+        def web_service_config
+          depends_on = { db: { condition: "service_healthy" } }
+
+          # Add Redis dependency if included
+          depends_on[:redis] = { condition: "service_started" } if config[:additional_services]&.include?("redis")
+
+          {
+            build: ".",
+            command: 'bash -c "rm -f tmp/pids/server.pid && bundle exec rails s -b \'0.0.0.0\'"',
+            volumes: [
+              ".:/rails",
+              "gem_cache:/usr/local/bundle"
+            ],
+            ports: ["3000:3000"],
+            depends_on: depends_on,
+            environment: web_environment,
+            stdin_open: true,
+            tty: true
+          }
+        end
+
+        def additional_services
+          services = {}
+
+          # Redis service
+          if config[:additional_services]&.include?("redis")
+            services[:redis] = {
+              image: "redis:7-alpine",
+              ports: ["6379:6379"],
+              volumes: ["redis_data:/data"]
+            }
+          end
+
+          # Sidekiq service
+          if config[:additional_services]&.include?("sidekiq")
+            services[:sidekiq] = {
+              build: ".",
+              command: "bundle exec sidekiq",
+              volumes: [
+                ".:/rails",
+                "gem_cache:/usr/local/bundle"
+              ],
+              depends_on: {
+                db: { condition: "service_healthy" },
+                redis: { condition: "service_started" }
+              },
+              environment: web_environment
+            }
+          end
+
+          # Mailcatcher service
+          if config[:additional_services]&.include?("mailcatcher")
+            services[:mailcatcher] = {
+              image: "schickling/mailcatcher",
+              ports: ["1080:1080", "1025:1025"]
+            }
+          end
+
+          services
+        end
+
+        def web_environment
+          env = {
+            "DATABASE_URL" => database_url,
+            "RAILS_ENV" => "development"
+          }
+
+          env["REDIS_URL"] = "redis://redis:6379/0" if config[:additional_services]&.include?("redis")
+
+          if config[:additional_services]&.include?("mailcatcher")
+            env["SMTP_HOST"] = "mailcatcher"
+            env["SMTP_PORT"] = "1025"
+          end
+
+          env
+        end
+
+        def database_url
+          case config[:database]
+          when "postgresql"
+            "postgresql://postgres:password@db:5432/#{config[:app_name]}_development"
+          when "mysql"
+            "mysql2://rails:password@db:3306/#{config[:app_name]}_development"
+          end
+        end
+
+        def compose_volumes
+          volumes = ["gem_cache"]
+
+          case config[:database]
+          when "postgresql"
+            volumes << "postgres_data"
+          when "mysql"
+            volumes << "mysql_data"
+          end
+
+          volumes << "redis_data" if config[:additional_services]&.include?("redis")
+
+          volumes
+        end
+
+        def compose_networks
+          {
+            default: {
+              driver: "bridge"
+            }
+          }
+        end
+
+        def dockerfile_packages
+          packages = %w[build-base git bash curl tzdata]
+
+          case config[:database]
+          when "postgresql"
+            packages << "postgresql-dev"
+          when "mysql"
+            packages << "mysql-dev"
+          end
+
+          packages << "nodejs" << "npm" # For asset pipeline
+          packages
+        end
+
+        def needs_custom_entrypoint?
+          config[:additional_services]&.any? || config[:database] != "sqlite3"
+        end
+      end
+    end
+  end
+end