discharger 0.2.30 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3e4862f36fb92472471e953ab1c29809d2e9e777a83ae9742d348ba9855d363c
-  data.tar.gz: 41b57081caa7c89bdd27ec7958cf1ac2e119ceac61420a7b9e3a138931f1cf5b
+  metadata.gz: 86a58f41a34e61bfc155a9563e55bbc1eb42d4bd6904c09fe4aafb9bc61f3411
+  data.tar.gz: 62d3b3ad5ffec0dcdee073f5ca0109416b383dd2fe180f8501af47f2028d9122
 SHA512:
-  metadata.gz: cb018aef528e7a3a9caf6c8e45ce61541bc5e0acb47558b0247da4df513a3389732d7509569b0b12daae8cda9eaa620f2f90bc70531820de2eccd81426b17d99
-  data.tar.gz: 8bb76e9bff688426a94d19d9d4887f986cf34afb9a023fc6e542fa8917ede77688b5948a48d410106b500ab6fc16d94d37a118eb0853b2696fffb79c1ee6d681
+  metadata.gz: d0f6c58d5fde62fb7dd63b5dbe56c867600eea46e5c8e74b9eee22025da5dd299bf9d0b1093a40a67411c5cc279b9ca826e0c6d0af8659635fb6692279fa8fab
+  data.tar.gz: 4ef09b9ca157755c99aa693d3c768e11df6f4fb470ed2d3c4736cf7c2fb894fb46352e941e550c2c200ec95bfd98f40a5daf22ca0928431231fdad04e07fe1ca

data/CHANGELOG.md

@@ -5,10 +5,14 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](http://keepachangelog.com/)
 and this project adheres to [Semantic Versioning](http://semver.org/).
 
-## [0.2.30] - 2026-03-11
+## [0.3.1] - 2026-05-13
 
-### Changed
+### Added
 
-- Use git trailer fragments for changelog generation (70396ca)
+- database.prefer_docker setup.yml option for explicit Docker vs native PostgreSQL selection (2fca81e)
 
-## [0.2.29] - 2026-03-10
+## [0.2.31] - 2026-04-09
+
+### Added
+
+- Unified setup entry point with pre-steps support (1459633)

data/README.md

@@ -163,6 +163,12 @@ database:
   name: "db-your-app"
   version: "14"
   password: "postgres"
+  # Optional. Controls how the docker step handles a native PostgreSQL
+  # already listening on the configured port:
+  #   omitted/nil/false - silently skip Docker and use the native instance (legacy default)
+  #   true              - always create the Docker container; fail if a native instance holds the port
+  #   "prompt"          - ask the developer (interactive shells only; non-interactive runs fall back to native)
+  prefer_docker: "prompt"
 
 redis:
   port: 6379
@@ -187,6 +193,30 @@ custom_steps:
     command: "bin/rails db:seed"
 ```
 
+### Pre-Rails Steps (Prerequisites)
+
+The `pre_steps` array defines commands that run **before Rails loads**. These are for system dependencies and environment setup that must be in place before bundler or Rails can initialize.
+
+Built-in pre_steps:
+- `homebrew` - Installs Homebrew if not present (macOS)
+- `postgresql_tools` - Installs PostgreSQL client tools (`pg_dump`, `psql`)
+
+```yaml
+pre_steps:
+  - homebrew
+  - postgresql_tools
+```
+
+You can also define custom pre_steps with shell commands:
+
+```yaml
+pre_steps:
+  - homebrew
+  - description: "Set up environment variables"
+    command: "cp .env.example .env"
+    condition: "!File.exist?('.env')"
+```
+
 ### Using Default Steps
 
 The `steps` array specifies which built-in setup commands to run. Available commands include:

data/lib/discharger/prerequisites.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+# Standalone loader for Discharger::SetupRunner::PrerequisitesLoader
+# This can be required before Rails loads to set up environment variables
+# and system dependencies.
+#
+# Usage in bin/setup:
+#   require "discharger/prerequisites"
+#   Discharger::SetupRunner::PrerequisitesLoader.run("config/setup.yml")
+#
+require_relative "setup_runner/pre_commands/base_pre_command"
+require_relative "setup_runner/pre_commands/homebrew_pre_command"
+require_relative "setup_runner/pre_commands/postgresql_tools_pre_command"
+require_relative "setup_runner/pre_commands/pre_command_registry"
+require_relative "setup_runner/prerequisites_loader"

data/lib/discharger/setup.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "pathname"
+
+# Unified entry point for Discharger setup.
+# Handles both pre-Rails prerequisites and post-Rails setup commands.
+#
+# Usage in bin/setup:
+#   require "discharger/setup"
+#   Discharger::Setup.run("config/setup.yml")
+#
+# This will automatically:
+# 1. Load bundler/setup (activates correct gem versions)
+# 2. Run pre_steps (before Rails loads) - env vars, homebrew, etc.
+# 3. Initialize Rails
+# 4. Run regular setup steps and custom_steps
+#
+module Discharger
+  class Setup
+    attr_reader :config_path, :app_root
+
+    def initialize(config_path, app_root: nil)
+      @config_path = config_path
+      @app_root = app_root || Dir.pwd
+    end
+
+    def self.run(config_path = "config/setup.yml", app_root: nil)
+      new(config_path, app_root: app_root).run
+    end
+
+    def run
+      FileUtils.chdir(app_root) do
+        validate_environment
+        print_header
+
+        # Phase 1: Load bundler first (activates correct gem versions)
+        # This must happen before we parse YAML to avoid psych version conflicts
+        load_bundler
+
+        # Phase 2: Pre-Rails setup (env vars, system dependencies)
+        # These run AFTER bundler but BEFORE Rails loads
+        run_prerequisites
+
+        # Phase 3: Load Rails (uses env vars from phase 2)
+        load_rails
+
+        # Phase 4: Run Discharger commands (after Rails loads)
+        run_setup_commands
+
+        print_footer
+      end
+    end
+
+    private
+
+    def validate_environment
+      unless File.exist?("Gemfile")
+        puts "No Gemfile found. Please run this script from the root of your Rails application."
+        exit 1
+      end
+
+      unless File.exist?(config_path)
+        puts "No #{config_path} found. Please run 'rails generate discharger:install' first."
+        exit 1
+      end
+    end
+
+    def print_header
+      puts "== Running Discharger setup =="
+      puts "Configuration loaded from: #{config_path}"
+    end
+
+    def print_footer
+      puts "\n== Setup completed successfully! =="
+    end
+
+    def load_bundler
+      require "bundler/setup"
+    end
+
+    def run_prerequisites
+      puts "\n== Setting up prerequisites =="
+      require_relative "prerequisites"
+      SetupRunner::PrerequisitesLoader.run(config_path)
+    end
+
+    def load_rails
+      # Load Rails from the standard location
+      rails_config = File.join(app_root, "config", "application.rb")
+      if File.exist?(rails_config)
+        require rails_config
+        Rails.application.initialize!
+      else
+        puts "Warning: config/application.rb not found. Skipping Rails initialization."
+      end
+    end
+
+    def run_setup_commands
+      require_relative "../discharger"
+      SetupRunner.run(config_path)
+    end
+  end
+end

data/lib/discharger/setup_runner/commands/base_command.rb

@@ -156,7 +156,12 @@ module Discharger
 
         def system_quiet(*args)
           require "open3"
-          stdout, _stderr, status = Open3.capture3(*args)
+          # If it's a single string with shell metacharacters, run it through bash
+          if args.size == 1 && args.first.is_a?(String) && args.first.match?(/[|><&;]/)
+            stdout, _stderr, status = Open3.capture3("bash", "-c", args.first)
+          else
+            stdout, _stderr, status = Open3.capture3(*args)
+          end
           logger&.debug("Quietly executed #{args.join(" ")} - success: #{status.success?}")
           logger&.debug("Output: #{stdout}") if stdout && !stdout.empty? && logger
           status.success?
@@ -172,10 +177,20 @@ module Discharger
         end
 
         def proceed_with(task)
-          return yield unless $stdin.tty?
+          # Auto-proceed in non-interactive environments (unless forced interactive for testing)
+          unless ENV["DISCHARGER_FORCE_INTERACTIVE"]
+            if ENV["CI"] || !$stdin.tty? || ENV["QUIET_SETUP"]
+              yield
+              return
+            end
+          end
 
-          puts "Proceed with #{task}?\n ===> Type Y to proceed\nOtherwise hit any key to ignore."
-          if gets&.chomp == "Y"
+          unless ENV["DISABLE_OUTPUT"]
+            puts "Proceed with #{task}?\n ===> Type Y to proceed\nOtherwise hit any key to ignore."
+          end
+
+          input = gets
+          if input&.chomp == "Y"
             yield
           end
         end

data/lib/discharger/setup_runner/commands/database_command.rb

@@ -11,17 +11,18 @@ module Discharger
           # Drop and recreate development database
           terminate_database_connections
           with_spinner("Dropping and recreating development database") do
-            _stdout, stderr, status = Open3.capture3("bash", "-c", "bin/rails db:drop db:create > /dev/null 2>&1")
+            stdout, stderr, status = Open3.capture3(db_env, "bin/rails", "db:drop", "db:create")
             if status.success?
               {success: true}
             else
-              {success: false, error: "Failed to drop/create database: #{stderr}"}
+              error_msg = stderr.empty? ? stdout : stderr
+              {success: false, error: "Failed to drop/create database: #{error_msg}"}
             end
           end
 
           # Load schema and run migrations
           with_spinner("Loading database schema and running migrations") do
-            _stdout, stderr, status = Open3.capture3("bin/rails db:schema:load db:migrate")
+            _stdout, stderr, status = Open3.capture3(db_env, "bin/rails", "db:schema:load", "db:migrate")
             if status.success?
               {success: true}
             else
@@ -30,9 +31,9 @@ module Discharger
           end
 
           # Seed the database
-          env = (config.respond_to?(:seed_env) && config.seed_env) ? {"SEED_DEV_ENV" => "true"} : {}
+          seed_env = db_env.merge((config.respond_to?(:seed_env) && config.seed_env) ? {"SEED_DEV_ENV" => "true"} : {})
           with_spinner("Seeding the database") do
-            _stdout, stderr, status = Open3.capture3(env, "bin/rails db:seed")
+            _stdout, stderr, status = Open3.capture3(seed_env, "bin/rails", "db:seed")
             if status.success?
               {success: true}
             else
@@ -43,11 +44,13 @@ module Discharger
           # Setup test database
           terminate_database_connections("test")
           with_spinner("Setting up test database") do
-            _stdout, stderr, status = Open3.capture3({"RAILS_ENV" => "test"}, "bash", "-c", "bin/rails db:drop db:create db:schema:load > /dev/null 2>&1")
+            test_env = db_env.merge({"RAILS_ENV" => "test"})
+            stdout, stderr, status = Open3.capture3(test_env, "bin/rails", "db:drop", "db:create", "db:schema:load")
             if status.success?
               {success: true}
             else
-              {success: false, error: "Failed to setup test database: #{stderr}"}
+              error_msg = stderr.empty? ? stdout : stderr
+              {success: false, error: "Failed to setup test database: #{error_msg}"}
             end
           end
 
@@ -72,6 +75,17 @@ module Discharger
 
         private
 
+        def db_env
+          # Use Docker PostgreSQL tools if bin/docker-pg directory exists
+          docker_pg_path = File.join(app_root, "bin", "docker-pg")
+          if File.directory?(docker_pg_path)
+            # Prepend docker-pg directory to PATH to use Docker's pg_dump/psql
+            {"PATH" => "#{docker_pg_path}:#{ENV["PATH"]}"}
+          else
+            {}
+          end
+        end
+
         def terminate_database_connections(rails_env = nil)
           # Use a Rails runner to terminate connections within the Rails context
           env_vars = rails_env ? {"RAILS_ENV" => rails_env} : {}

data/lib/discharger/setup_runner/commands/docker_command.rb

@@ -7,48 +7,98 @@ module Discharger
     module Commands
       class DockerCommand < BaseCommand
         def execute
-          # Setup database container if configured
-          if config.respond_to?(:database) && config.database
+          setup_database if database_configured?
+          setup_redis if redis_configured?
+        end
+
+        def can_execute?
+          # Only execute if Docker is available and containers are configured
+          docker_available? && (database_configured? || redis_configured?)
+        end
+
+        def description
+          "Setup Docker containers"
+        end
+
+        private
+
+        def setup_database
+          puts "  → Checking database configuration..." unless ENV["QUIET_SETUP"]
+
+          case database_config.prefer_docker
+          when true
+            create_database_container_or_fail
+          when "prompt"
+            if native_postgresql_available? && wants_native_postgresql?
+              use_native_postgresql
+            else
+              create_database_container_or_fail
+            end
+          else
+            # Legacy default: prefer the native instance when one is available.
             if native_postgresql_available?
-              log "Native PostgreSQL detected on port #{native_postgresql_port}, skipping Docker container setup"
-              ENV["DB_PORT"] ||= native_postgresql_port.to_s
+              use_native_postgresql
             else
-              ensure_docker_running
-              setup_container(
-                name: config.database.name || "db-app",
-                port: config.database.port || 5432,
-                image: "postgres:#{config.database.version || "14"}",
-                env: {"POSTGRES_PASSWORD" => config.database.password || "postgres"},
-                volume: "#{config.database.name || "db-app"}:/var/lib/postgresql/data",
-                internal_port: 5432
-              )
+              create_database_container
             end
           end
+        end
+
+        def setup_redis
+          setup_container(
+            name: redis_config.name || "redis-app",
+            port: redis_config.port || 6379,
+            image: "redis:#{redis_config.version || "latest"}",
+            internal_port: 6379
+          )
+        end
+
+        def use_native_postgresql
+          puts "  → Native PostgreSQL detected on port #{native_postgresql_port}, skipping Docker setup" unless ENV["QUIET_SETUP"]
+          ENV["DB_PORT"] ||= native_postgresql_port.to_s
+        end
 
-          # Setup Redis container if configured
-          if config.respond_to?(:redis) && config.redis
-            setup_container(
-              name: config.redis.name || "redis-app",
-              port: config.redis.port || 6379,
-              image: "redis:#{config.redis.version || "latest"}",
-              internal_port: 6379
-            )
+        def create_database_container_or_fail
+          if native_postgresql_available?
+            raise "prefer_docker is set in the database config but native PostgreSQL is " \
+                  "listening on port #{native_postgresql_port}. Stop the native instance " \
+                  "(e.g., `brew services stop postgresql@15`) or remove prefer_docker."
           end
+          create_database_container
         end
 
-        def can_execute?
-          # Only execute if Docker is available and containers are configured
-          docker_available? && (
-            (config.respond_to?(:database) && config.database) ||
-            (config.respond_to?(:redis) && config.redis)
+        def create_database_container
+          puts "  → No native PostgreSQL found, setting up Docker container..." unless ENV["QUIET_SETUP"]
+          ensure_docker_running
+          setup_container(
+            name: database_config.name || "db-app",
+            port: database_config.port || 5432,
+            image: "postgres:#{database_config.version || "14"}",
+            env: {"POSTGRES_PASSWORD" => database_config.password || "postgres"},
+            volume: "#{database_config.name || "db-app"}:/var/lib/postgresql/data",
+            internal_port: 5432
           )
         end
 
-        def description
-          "Setup Docker containers"
+        # Ask the developer whether to use the detected native PostgreSQL or set up
+        # the configured Docker container instead. Falls back to native (the legacy
+        # behavior) when stdin is not a TTY, in CI, or when QUIET_SETUP is set,
+        # so non-interactive runs do not hang waiting for input.
+        def wants_native_postgresql?
+          unless interactive_prompt_available?
+            puts "  → Non-interactive shell; defaulting to native PostgreSQL on port #{native_postgresql_port}" unless ENV["QUIET_SETUP"]
+            return true
+          end
+
+          puts "Native PostgreSQL detected on port #{native_postgresql_port}. Use the Docker container anyway?\n ===> Type Y to set up the Docker container\nOtherwise hit any key to use the native PostgreSQL."
+          $stdin.gets&.chomp != "Y"
         end
 
-        private
+        def interactive_prompt_available?
+          return true if ENV["DISCHARGER_FORCE_INTERACTIVE"]
+          return false if ENV["CI"] || ENV["QUIET_SETUP"]
+          $stdin.tty?
+        end
 
         def setup_container(name:, port:, image:, internal_port:, env: {}, volume: nil)
           log "Checking #{name} container"
@@ -151,12 +201,41 @@ module Discharger
           true
         end
 
+        def database_configured?
+          config.respond_to?(:database) && config.database&.name
+        end
+
+        def redis_configured?
+          config.respond_to?(:redis) && config.redis&.name
+        end
+
+        def database_config
+          config.database
+        end
+
+        def redis_config
+          config.redis
+        end
+
         def native_postgresql_available?
-          configured_port = (config.database&.port || 5432).to_i
+          # If a specific port is configured, ONLY check that port
+          # We should not use a native PostgreSQL on a different port
+          configured_port = config.database&.port
+          if configured_port
+            if postgresql_running_on_port?(configured_port)
+              @native_pg_port = configured_port
+              return true
+            end
+            # Configured port specified but PostgreSQL not running on it
+            return false
+          end
 
-          if postgresql_running_on_port?(configured_port)
-            @native_pg_port = configured_port
-            return true
+          # No specific port configured, check common PostgreSQL ports
+          [5432, 5433].each do |port|
+            if postgresql_running_on_port?(port)
+              @native_pg_port = port
+              return true
+            end
           end
           false
         end

data/lib/discharger/setup_runner/configuration.rb

@@ -5,15 +5,16 @@ require "yaml"
 module Discharger
   module SetupRunner
     class Configuration
-      attr_accessor :app_name, :database, :redis, :services, :steps, :custom_steps
+      attr_accessor :app_name, :database, :redis, :services, :steps, :custom_steps, :pre_steps
 
       def initialize
         @app_name = "Application"
         @database = DatabaseConfig.new
-        @redis = RedisConfig.new
+        @redis = nil
         @services = []
         @steps = []
         @custom_steps = []
+        @pre_steps = []
       end
 
       def self.from_file(path)
@@ -25,23 +26,25 @@ module Discharger
 
         config.app_name = yaml["app_name"] if yaml["app_name"]
         config.database.from_hash(yaml["database"]) if yaml["database"]
-        config.redis.from_hash(yaml["redis"]) if yaml["redis"]
+        config.redis = RedisConfig.new.tap { |r| r.from_hash(yaml["redis"]) } if yaml["redis"]
         config.services = yaml["services"] || []
         config.steps = yaml["steps"] || []
         config.custom_steps = yaml["custom_steps"] || []
+        config.pre_steps = yaml["pre_steps"] || []
 
         config
       end
     end
 
     class DatabaseConfig
-      attr_accessor :port, :name, :version, :password
+      attr_accessor :port, :name, :version, :password, :prefer_docker
 
       def initialize
         @port = 5432
         @name = "db-app"
         @version = "14"
         @password = "postgres"
+        @prefer_docker = nil
       end
 
       def from_hash(hash)
@@ -49,6 +52,7 @@ module Discharger
         @name = hash["name"] if hash["name"]
         @version = hash["version"] if hash["version"]
         @password = hash["password"] if hash["password"]
+        @prefer_docker = hash["prefer_docker"] if hash.key?("prefer_docker")
       end
     end
 

data/lib/discharger/setup_runner/pre_commands/base_pre_command.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "rbconfig"
+
+module Discharger
+  module SetupRunner
+    module PreCommands
+      # Base class for pre-Rails commands.
+      # These commands run BEFORE bundler/Rails loads, so they must be
+      # pure Ruby with no gem dependencies.
+      class BasePreCommand
+        attr_reader :config
+
+        def initialize(config = {})
+          @config = config
+        end
+
+        def execute
+          raise NotImplementedError, "#{self.class} must implement #execute"
+        end
+
+        def description
+          self.class.name.split("::").last.gsub(/PreCommand$/, "").gsub(/([a-z])([A-Z])/, '\1 \2')
+        end
+
+        protected
+
+        def log(message)
+          puts "  #{message}"
+        end
+
+        def platform_darwin?
+          RbConfig::CONFIG["host_os"] =~ /darwin/
+        end
+
+        def platform_linux?
+          RbConfig::CONFIG["host_os"] =~ /linux/
+        end
+
+        def command_exists?(command)
+          system("which #{command} > /dev/null 2>&1")
+        end
+      end
+    end
+  end
+end

data/lib/discharger/setup_runner/pre_commands/homebrew_pre_command.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require_relative "base_pre_command"
+
+module Discharger
+  module SetupRunner
+    module PreCommands
+      # Ensures Homebrew/Linuxbrew is installed.
+      # This must run before `brew bundle` can install Brewfile dependencies.
+      class HomebrewPreCommand < BasePreCommand
+        HOMEBREW_INSTALL_URL = "https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh"
+        LINUXBREW_PATH = "/home/linuxbrew/.linuxbrew/bin"
+
+        def execute
+          if command_exists?("brew")
+            log "Homebrew found at: #{`which brew`.strip}"
+            return true
+          end
+
+          log "Homebrew not found. Installing..."
+
+          if platform_darwin?
+            install_homebrew_macos
+          elsif platform_linux?
+            install_homebrew_linux
+          else
+            log "WARNING: Unsupported platform for automatic Homebrew installation"
+            log "Please install Homebrew manually: https://brew.sh"
+            return false
+          end
+
+          verify_installation
+        end
+
+        def description
+          "Ensure Homebrew is installed"
+        end
+
+        private
+
+        def install_homebrew_macos
+          log "Installing Homebrew for macOS..."
+          system(%(/bin/bash -c "$(curl -fsSL #{HOMEBREW_INSTALL_URL})"))
+        end
+
+        def install_homebrew_linux
+          log "Installing Linuxbrew for Linux..."
+          system(%(/bin/bash -c "$(curl -fsSL #{HOMEBREW_INSTALL_URL})"))
+
+          # Add Linuxbrew to PATH for current session
+          if File.exist?(LINUXBREW_PATH)
+            ENV["PATH"] = "#{LINUXBREW_PATH}:#{ENV["PATH"]}"
+            log "Added Linuxbrew to PATH"
+          end
+        end
+
+        def verify_installation
+          unless command_exists?("brew")
+            log "ERROR: Homebrew installation failed or not in PATH"
+            log "Please install Homebrew manually and ensure it's in your PATH"
+            return false
+          end
+          log "Homebrew installed successfully"
+          true
+        end
+      end
+    end
+  end
+end

data/lib/discharger/setup_runner/pre_commands/postgresql_tools_pre_command.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require_relative "base_pre_command"
+
+module Discharger
+  module SetupRunner
+    module PreCommands
+      # Ensures PostgreSQL client tools (pg_dump, psql) are installed.
+      # These tools are needed for database operations like db:structure:dump.
+      class PostgresqlToolsPreCommand < BasePreCommand
+        def execute
+          if command_exists?("pg_dump")
+            log "PostgreSQL client tools found"
+            return true
+          end
+
+          log "PostgreSQL client tools (pg_dump) not found."
+          pg_version = config.dig("database", "version") || "14"
+
+          if platform_darwin?
+            install_via_homebrew(pg_version)
+          elsif platform_linux?
+            install_via_apt(pg_version)
+          else
+            log "WARNING: Unsupported platform for PostgreSQL client tools installation"
+            false
+          end
+        end
+
+        def description
+          "Ensure PostgreSQL client tools are installed"
+        end
+
+        private
+
+        def install_via_homebrew(version)
+          log "Installing PostgreSQL #{version} client tools via Homebrew..."
+          if system("brew install postgresql@#{version}")
+            log "PostgreSQL #{version} client tools installed successfully"
+            true
+          else
+            log "WARNING: Failed to install PostgreSQL client tools"
+            log "Please install manually: brew install postgresql@#{version}"
+            false
+          end
+        end
+
+        def install_via_apt(version)
+          unless command_exists?("apt-get")
+            log "WARNING: apt-get not found"
+            log "Please install postgresql-client-#{version} using your system's package manager"
+            return false
+          end
+
+          log "Installing PostgreSQL #{version} client tools via apt..."
+          if system("sudo apt-get install -y postgresql-client-#{version}")
+            # Set up alternatives for the installed version
+            priority = version.to_i * 10
+            system("sudo update-alternatives --install /usr/bin/pg_dump pg_dump /usr/lib/postgresql/#{version}/bin/pg_dump #{priority}")
+            system("sudo update-alternatives --install /usr/bin/psql psql /usr/lib/postgresql/#{version}/bin/psql #{priority}")
+            log "PostgreSQL #{version} client tools installed successfully"
+            true
+          else
+            log "WARNING: Failed to install PostgreSQL client tools"
+            log "Please install manually: sudo apt-get install postgresql-client-#{version}"
+            false
+          end
+        end
+      end
+    end
+  end
+end

data/lib/discharger/setup_runner/pre_commands/pre_command_registry.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative "homebrew_pre_command"
+require_relative "postgresql_tools_pre_command"
+
+module Discharger
+  module SetupRunner
+    module PreCommands
+      # Registry for pre-Rails commands.
+      # Maps command names (from setup.yml) to command classes.
+      class PreCommandRegistry
+        BUILT_IN_COMMANDS = {
+          "homebrew" => HomebrewPreCommand,
+          "postgresql_tools" => PostgresqlToolsPreCommand
+        }.freeze
+
+        class << self
+          def get(name)
+            custom_commands[name.to_s] || BUILT_IN_COMMANDS[name.to_s]
+          end
+
+          def register(name, command_class)
+            custom_commands[name.to_s] = command_class
+          end
+
+          def names
+            (BUILT_IN_COMMANDS.keys + custom_commands.keys).uniq
+          end
+
+          private
+
+          def custom_commands
+            @custom_commands ||= {}
+          end
+        end
+      end
+    end
+  end
+end

data/lib/discharger/setup_runner/prerequisites_loader.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+require "yaml"
+require_relative "pre_commands/pre_command_registry"
+
+module Discharger
+  module SetupRunner
+    # PrerequisitesLoader handles setup tasks that must run BEFORE Rails loads.
+    # This includes setting environment variables, checking for system dependencies,
+    # and installing tools like Homebrew that are needed before bundler/Rails can run.
+    #
+    # Usage in bin/setup:
+    #   require "discharger/prerequisites"
+    #   Discharger::SetupRunner::PrerequisitesLoader.run("config/setup.yml")
+    #
+    class PrerequisitesLoader
+      attr_reader :config_path, :config
+
+      def initialize(config_path)
+        @config_path = config_path
+        @config = load_config
+      end
+
+      def self.run(config_path)
+        new(config_path).run
+      end
+
+      def run
+        return false unless config
+
+        set_database_environment
+        run_pre_steps
+        true
+      end
+
+      private
+
+      def load_config
+        return nil unless File.exist?(config_path)
+
+        YAML.load_file(config_path)
+      rescue => e
+        puts "Warning: Could not load #{config_path}: #{e.message}"
+        nil
+      end
+
+      def set_database_environment
+        return unless config["database"]
+
+        db_config = config["database"]
+        set_db_port(db_config)
+        set_db_name(db_config)
+      end
+
+      def set_db_port(db_config)
+        if db_config["port"] && !ENV["DB_PORT"]
+          ENV["DB_PORT"] = db_config["port"].to_s
+          ENV["PGPORT"] = db_config["port"].to_s
+          puts "  Setting DB_PORT=#{db_config["port"]} from config/setup.yml"
+        elsif ENV["DB_PORT"]
+          warn_if_mismatch("DB_PORT", ENV["DB_PORT"], db_config["port"].to_s)
+          ENV["PGPORT"] = ENV["DB_PORT"]
+        end
+      end
+
+      def set_db_name(db_config)
+        if db_config["name"] && !ENV["DB_NAME"]
+          container_name = db_config["name"].to_s
+          db_name = container_name.sub(/^db-/, "")
+          ENV["DB_NAME"] = db_name
+          puts "  Setting DB_NAME=#{db_name} from config/setup.yml (container: #{container_name})"
+        elsif ENV["DB_NAME"]
+          container_name = db_config["name"].to_s
+          expected_db_name = container_name.sub(/^db-/, "")
+          warn_if_mismatch("DB_NAME", ENV["DB_NAME"], expected_db_name)
+        end
+      end
+
+      def warn_if_mismatch(var_name, env_value, config_value)
+        return unless config_value && env_value != config_value
+        puts "\n⚠️  WARNING: #{var_name} environment variable (#{env_value}) differs from config/setup.yml (#{config_value})"
+        puts "   Using environment variable value. To use config/setup.yml value, unset #{var_name}."
+      end
+
+      def run_pre_steps
+        pre_steps = config["pre_steps"] || []
+        pre_steps.each do |step|
+          run_pre_step(step)
+        end
+      end
+
+      def run_pre_step(step)
+        case step
+        when String
+          run_built_in_pre_step(step)
+        when Hash
+          run_custom_pre_step(step)
+        end
+      end
+
+      def run_built_in_pre_step(name)
+        command_class = PreCommands::PreCommandRegistry.get(name)
+        unless command_class
+          puts "  WARNING: Unknown pre-step '#{name}'"
+          return
+        end
+
+        command = command_class.new(config)
+        puts "  #{command.description}..."
+        command.execute
+      end
+
+      def run_custom_pre_step(step)
+        description = step["description"] || step["command"]
+        command = step["command"]
+        condition = step["condition"]
+
+        if condition && !evaluate_condition(condition)
+          puts "  Skipping: #{description} (condition not met)"
+          return
+        end
+
+        puts "  Running: #{description}"
+        system(command)
+      end
+
+      def evaluate_condition(condition)
+        case condition
+        when /^ENV\['(\w+)'\]$/
+          !ENV[$1].nil? && !ENV[$1].empty?
+        when /^!ENV\['(\w+)'\]$/
+          ENV[$1].nil? || ENV[$1].empty?
+        when /^File\.exist\?\(['"](.+)['"]\)$/
+          File.exist?($1)
+        when /^!File\.exist\?\(['"](.+)['"]\)$/
+          !File.exist?($1)
+        else
+          false
+        end
+      end
+    end
+  end
+end

data/lib/discharger/setup_runner.rb

@@ -5,6 +5,7 @@ require_relative "setup_runner/configuration"
 require_relative "setup_runner/command_registry"
 require_relative "setup_runner/command_factory"
 require_relative "setup_runner/runner"
+require_relative "setup_runner/prerequisites_loader"
 
 module Discharger
   module SetupRunner

data/lib/discharger/task.rb

@@ -193,6 +193,16 @@ module Discharger
       pr.empty? ? nil : pr
     end
 
+    def pr_already_merged?(pr_ref)
+      stdout, _, status = Open3.capture3(
+        "gh", "pr", "view", pr_ref.to_s,
+        "--json", "state",
+        "--jq", ".state"
+      )
+      return false unless status.success?
+      stdout.strip == "MERGED"
+    end
+
     def define
       require "slack-ruby-client"
       Slack.configure do |config|
@@ -262,9 +272,13 @@ module Discharger
           end
         end
 
-        syscall(
-          ["gh pr merge #{pr_ref} --merge"]
-        )
+        if pr_already_merged?(pr_ref)
+          sysecho "PR #{pr_ref} is already merged. Continuing..."
+        else
+          syscall(
+            ["gh pr merge #{pr_ref} --merge"]
+          )
+        end
 
         continue = syscall(
           ["git fetch origin #{production_branch}:#{production_branch}"],

data/lib/discharger/version.rb

@@ -1,3 +1,3 @@
 module Discharger
-  VERSION = "0.2.30"
+  VERSION = "0.3.1"
 end

data/lib/generators/discharger/install/templates/setup

@@ -1,36 +1,30 @@
 #!/usr/bin/env ruby
-require "fileutils"
-require "pathname"
-require "bundler/setup"
 
 # Path to the application root.
 APP_ROOT = File.expand_path("..", __dir__)
 
-FileUtils.chdir APP_ROOT do
+Dir.chdir(APP_ROOT) do
   # This script uses Discharger to set up your development environment automatically.
   # All setup steps are configured in config/setup.yml
   # This script is idempotent, so you can run it at any time and get an expectable outcome.
 
-  unless File.exist?("Gemfile")
-    puts "No Gemfile found. Please run this script from the root of your Rails application."
-    exit 1
+  # Find discharger gem path from Gemfile without loading bundler
+  # (loading bundler early can cause gem version conflicts)
+  gemfile = File.read("Gemfile")
+  if (match = gemfile.match(/gem\s+["']discharger["'].*path:\s*["']([^"']+)["']/))
+    discharger_path = File.expand_path(match[1], APP_ROOT)
+    $LOAD_PATH.unshift(File.join(discharger_path, "lib"))
+  else
+    # Fall back to installed gem
+    begin
+      gem "discharger"
+    rescue Gem::MissingSpecError
+      puts "Could not find discharger gem."
+      puts "If using a custom bundle path, try: bundle exec bin/setup"
+      exit 1
+    end
   end
 
-  unless File.exist?("config/setup.yml")
-    puts "No config/setup.yml found. Please run 'rails generate discharger:install' first."
-    exit 1
-  end
-
-  puts "== Running Discharger setup =="
-  puts "Configuration loaded from: config/setup.yml"
-
-  # Load Rails environment first, then discharger
-  require_relative "../config/application"
-  Rails.application.initialize!
-
-  # Load the discharger gem and run the setup
-  require "discharger"
-  Discharger::SetupRunner.run("config/setup.yml")
-
-  puts "\n== Setup completed successfully! =="
+  require "discharger/setup"
+  Discharger::Setup.run("config/setup.yml")
 end

data/lib/generators/discharger/install/templates/setup.yml

@@ -8,7 +8,7 @@ app_name: "YourAppName"
 # Database configuration
 database:
   port: 5432
-  name: "db-your-app"
+  name: "db-your-app"  # Docker container name. Rails will use "your-app" for database names
   version: "14"
   password: "postgres"
 
@@ -18,6 +18,23 @@ redis:
   name: "redis-your-app"
   version: "latest"
 
+# Pre-Rails steps (run BEFORE Rails loads)
+# These are for system dependencies and environment setup that must happen
+# before bundler/Rails can initialize. Use sparingly.
+#
+# Built-in pre_steps:
+#   - homebrew         # Installs Homebrew if not present
+#   - postgresql_tools # Installs PostgreSQL client tools (pg_dump, psql)
+#
+# Custom pre_steps (run shell commands):
+#   - description: "Description of step"
+#     command: "shell command to run"
+#     condition: "ENV['VAR']"  # Optional: only run if condition is true
+#
+pre_steps: []
+  # - homebrew
+  # - postgresql_tools
+
 # Built-in commands to run (empty array runs all available commands)
 # Available commands: brew, asdf, git, bundler, yarn, config, docker, pg_tools, env, database
 steps:
@@ -32,30 +49,22 @@ steps:
   - env
   - database
 
-# Custom commands for application-specific setup
+# Custom commands for application-specific setup (run AFTER Rails loads)
 custom_steps:
   - description: "Seed application data"
     command: "bin/rails db:seed"
-  
-  - description: "Setup application-specific configurations"
-    command: "bin/rails runner 'YourAppSetup.new.configure'"
-    condition: "defined?(YourAppSetup)"
-  
-  - description: "Import application data"
-    command: "bin/rails db:seed:import"
-    condition: "File.exist?('db/seeds/import.rb')"
-  
+
   # Example: Conditional setup based on environment variable
   # - description: "Seed legacy data"
   #   command: "LEGACY_DATA=true bin/rails db:seed"
   #   condition: "ENV['LEGACY_DATA'] == 'true'"
-  
+
   # Example: Setup external services
   # - description: "Setup Elasticsearch"
   #   command: "bin/rails search:setup"
   #   condition: "defined?(Elasticsearch)"
-  
+
   # Example: Setup background job processing
   # - description: "Setup Sidekiq"
   #   command: "bundle exec sidekiq -d"
-  #   condition: "defined?(Sidekiq)" 
+  #   condition: "defined?(Sidekiq)"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: discharger
 version: !ruby/object:Gem::Version
-  version: 0.2.30
+  version: 0.3.1
 platform: ruby
 authors:
 - Jim Gay
@@ -106,7 +106,9 @@ files:
 - README.md
 - Rakefile
 - lib/discharger.rb
+- lib/discharger/prerequisites.rb
 - lib/discharger/railtie.rb
+- lib/discharger/setup.rb
 - lib/discharger/setup_runner.rb
 - lib/discharger/setup_runner/command_factory.rb
 - lib/discharger/setup_runner/command_registry.rb
@@ -124,6 +126,11 @@ files:
 - lib/discharger/setup_runner/commands/yarn_command.rb
 - lib/discharger/setup_runner/condition_evaluator.rb
 - lib/discharger/setup_runner/configuration.rb
+- lib/discharger/setup_runner/pre_commands/base_pre_command.rb
+- lib/discharger/setup_runner/pre_commands/homebrew_pre_command.rb
+- lib/discharger/setup_runner/pre_commands/postgresql_tools_pre_command.rb
+- lib/discharger/setup_runner/pre_commands/pre_command_registry.rb
+- lib/discharger/setup_runner/prerequisites_loader.rb
 - lib/discharger/setup_runner/runner.rb
 - lib/discharger/setup_runner/version.rb
 - lib/discharger/task.rb