discharger 0.2.10 → 0.2.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 123fc77a1effa1f7cd70e68b9056cfb9d9491069edafca3939b40c092cf580fd
-  data.tar.gz: 9800b64540311c15e0805d835e6f137e39b5751a932ee3106406743b21353d8e
+  metadata.gz: 23bf801a204e17e5f37876fba770bc9610814b629ee570924c04414547bc801b
+  data.tar.gz: 594b4fceeb396a77ada63a549eee831d72ea6b1c942ff1a1ac813cea877e6c56
 SHA512:
-  metadata.gz: f840bfaf4c5db5c4321263d968d7fda42388d978fa49571bf78be219b64afcd52b9e06e870fe6d33fdd54b417104d1646dbbed4bf77ab42c154ff851d68da96c
-  data.tar.gz: 6dc97ddbfe29459973e3d2eaee4fa299c644112b5d0a3c3c65d566015c7018ba3ae4c0da0265781fc3d6785c0bbfe38bca0bdacbede5584646cafdaa09dff8bc
+  metadata.gz: ec6dadb8198acd18144256694bcfdd0cd7c58275e6ad8f2ed6d9bc374633db99e6bf50278fb137a7675af74759e9ecc885dc8450852e2561655b0d5ba6e2cf75
+  data.tar.gz: fcf463c7d4e9721b4a94a470a6ee0b75673888cf0f0c9e87fa998f208e0a3a1a88d8338de4add5ae1205f1a643e0ae49b59f814bf28854c5cd78bb5a09b96b0e

data/README.md

@@ -58,6 +58,16 @@ $ gem install discharger
 
 This gem is managed with [Reissue](https://github.com/SOFware/reissue).
 
+### Releasing
+
+Releases are automated via GitHub Actions:
+
+1. Go to Actions → "Prepare Release" → Run workflow
+2. Select version type (major, minor, patch, or custom)
+3. Review the created PR with version bumps and changelog updates
+4. Add the `approved-release` label and merge
+5. The gem will be automatically published to RubyGems.org
+
 Bug reports and pull requests are welcome on GitHub.
 
 ## License

data/Rakefile

@@ -7,7 +7,9 @@ require "reissue/gem"
 
 Reissue::Task.create :reissue do |task|
   task.version_file = "lib/discharger/version.rb"
-  task.commit = true
+  task.commit = !ENV["GITHUB_ACTIONS"]
+  task.commit_finalize = !ENV["GITHUB_ACTIONS"]
+  task.push_finalize = :branch
 end
 
 Rake::TestTask.new(:test) do |t|

data/lib/discharger/setup_runner/command_factory.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require_relative "command_registry"
+
+module Discharger
+  module SetupRunner
+    class CommandFactory
+      attr_reader :config, :app_root, :logger
+
+      def initialize(config, app_root, logger)
+        @config = config
+        @app_root = app_root
+        @logger = logger
+      end
+
+      def create_command(name)
+        command_class = CommandRegistry.get(name)
+        return nil unless command_class
+
+        command_class.new(config, app_root, logger)
+      rescue => e
+        logger&.warn "Failed to create command #{name}: #{e.message}"
+        nil
+      end
+
+      def create_all_commands
+        commands = []
+
+        # Create built-in commands from steps
+        if config.steps.any?
+          config.steps.each do |step|
+            command = create_command(step)
+            commands << command if command
+          end
+        else
+          # If no steps specified, create all registered commands
+          CommandRegistry.names.each do |name|
+            command = create_command(name)
+            commands << command if command
+          end
+        end
+
+        # Create custom commands
+        if config.respond_to?(:custom_steps) && config.custom_steps.any?
+          require_relative "commands/custom_command"
+          config.custom_steps.each do |step_config|
+            command = Commands::CustomCommand.new(config, app_root, logger, step_config)
+            commands << command
+          end
+        end
+
+        commands
+      end
+    end
+  end
+end

data/lib/discharger/setup_runner/command_registry.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Discharger
+  module SetupRunner
+    class CommandRegistry
+      class << self
+        def register(name, command_class)
+          commands[name.to_s] = command_class
+        end
+
+        def get(name)
+          commands[name.to_s]
+        end
+
+        def all
+          commands.values
+        end
+
+        def names
+          commands.keys
+        end
+
+        def clear
+          commands.clear
+        end
+
+        def load_commands
+          # Load base command first
+          require_relative "commands/base_command"
+
+          # Load all command files from the commands directory
+          commands_dir = File.expand_path("commands", __dir__)
+          Dir.glob(File.join(commands_dir, "*_command.rb")).each do |file|
+            require file
+          end
+
+          # Auto-register commands based on naming convention
+          Commands.constants.each do |const_name|
+            next unless const_name.to_s.end_with?("Command")
+
+            command_class = Commands.const_get(const_name)
+            next unless command_class < Commands::BaseCommand
+            next if command_class == Commands::BaseCommand
+
+            # Convert class name to command name (e.g., AsdfCommand -> asdf)
+            command_name = const_name.to_s.sub(/Command$/, "").gsub(/([A-Z])/, '_\1').downcase.sub(/^_/, "")
+            register(command_name, command_class)
+          end
+        end
+
+        private
+
+        def commands
+          @commands ||= {}
+        end
+      end
+
+      # Load and register all built-in commands
+      load_commands
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require_relative "base_command"
+
+module Discharger
+  module SetupRunner
+    module Commands
+      class AsdfCommand < BaseCommand
+        def execute
+          log "Install tool-versions dependencies via ASDF"
+
+          unless system_quiet("which asdf")
+            log "asdf not installed. Run `brew install asdf` if you want bin/setup to ensure versions are up-to-date"
+            return
+          end
+
+          tools_versions_file = File.join(app_root, ".tool-versions")
+          return log("No .tool-versions file found") unless File.exist?(tools_versions_file)
+
+          dependencies = File.read(tools_versions_file).split("\n")
+          installables = []
+
+          # Check for nodejs plugin
+          unless system_quiet("asdf plugin list | grep nodejs")
+            node_deps = dependencies.select { |item| item.match?(/node/) }
+            if node_deps.any?
+              ask_to_install "asdf to manage Node JS" do
+                installables.concat(node_deps)
+                system! "asdf plugin add nodejs https://github.com/asdf-vm/asdf-nodejs.git"
+              end
+            end
+          end
+
+          # Check for ruby plugin
+          unless system_quiet("asdf plugin list | grep ruby")
+            ruby_deps = dependencies.select { |item| item.match?(/ruby/) }
+            if ruby_deps.any?
+              ask_to_install "asdf to manage Ruby" do
+                installables.concat(ruby_deps)
+                system! "asdf plugin add ruby https://github.com/asdf-vm/asdf-ruby.git"
+              end
+            end
+          end
+
+          # Install all versions
+          installables.each do |name_version|
+            system! "asdf install #{name_version}"
+          end
+        end
+
+        def can_execute?
+          File.exist?(File.join(app_root, ".tool-versions"))
+        end
+
+        def description
+          "Install tool versions with asdf"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+module Discharger
+  module SetupRunner
+    module Commands
+      class BaseCommand
+        attr_reader :config, :app_root, :logger
+
+        def initialize(config, app_root, logger)
+          @config = config
+          @app_root = app_root
+          @logger = logger
+        end
+
+        def execute
+          raise NotImplementedError, "#{self.class} must implement #execute"
+        end
+
+        def can_execute?
+          true
+        end
+
+        def description
+          class_name = self.class.name || "AnonymousCommand"
+          class_name.demodulize.underscore.humanize
+        end
+
+        protected
+
+        def log(message, emoji: nil)
+          return unless logger
+          class_name = self.class.name || "AnonymousCommand"
+          prefix = emoji ? "#{emoji} " : ""
+          logger.info "#{prefix}[#{class_name.demodulize}] #{message}"
+        end
+
+        def with_spinner(message)
+          if ENV["CI"] || ENV["NO_SPINNER"] || !$stdout.tty? || ENV["QUIET_SETUP"]
+            result = yield
+            # Handle error case when spinner is disabled
+            if result.is_a?(Hash) && !result[:success] && result[:raise_error] != false
+              raise result[:error]
+            end
+            return result
+          end
+
+          require "rainbow"
+          spinner_chars = %w[⠋ ⠙ ⠹ ⠸ ⠼ ⠴ ⠦ ⠧ ⠇ ⠏]
+          spinner_thread = nil
+          stop_spinner = false
+
+          begin
+            # Print initial message
+            print Rainbow("◯ #{message}").cyan
+            $stdout.flush
+
+            # Start spinner in background thread
+            spinner_thread = Thread.new do
+              i = 0
+              until stop_spinner
+                print "\r#{Rainbow(spinner_chars[i % spinner_chars.length]).cyan} #{Rainbow(message).cyan}"
+                $stdout.flush
+                sleep 0.1
+                i += 1
+              end
+            end
+
+            # Execute the block
+            result = yield
+
+            # Stop spinner
+            stop_spinner = true
+            spinner_thread&.join(0.1)
+
+            # Clear line and print result
+            if result.is_a?(Hash)
+              if result[:success]
+                puts "\r#{Rainbow(result[:message] || "✓").green} #{message}"
+              else
+                puts "\r#{Rainbow(result[:message] || "✗").red} #{message}"
+                raise result[:error] if result[:error] && result[:raise_error] != false
+              end
+            else
+              puts "\r#{Rainbow("✓").green} #{message}"
+            end
+
+            result
+          rescue
+            stop_spinner = true
+            spinner_thread&.join(0.1)
+            puts "\r#{Rainbow("✗").red} #{message}"
+            raise
+          ensure
+            stop_spinner = true
+            spinner_thread&.kill if spinner_thread&.alive?
+          end
+        end
+
+        def simple_action(message)
+          return yield if ENV["CI"] || ENV["NO_SPINNER"] || !$stdout.tty? || ENV["QUIET_SETUP"]
+
+          require "rainbow"
+          print Rainbow("  → #{message}...").cyan
+          $stdout.flush
+
+          begin
+            result = yield
+            puts Rainbow(" ✓").green
+            result
+          rescue
+            puts Rainbow(" ✗").red
+            raise
+          end
+        end
+
+        def system!(*args)
+          require "open3"
+          command_str = args.join(" ")
+
+          # Create a more readable message for the spinner
+          spinner_message = if command_str.length > 80
+            if args.first.is_a?(Hash)
+              # Skip env hash in display
+              cmd_args = args[1..]
+              base_cmd = cmd_args.take(3).join(" ")
+            else
+              base_cmd = args.take(3).join(" ")
+            end
+            "Executing #{base_cmd}..."
+          else
+            "Executing #{command_str}"
+          end
+
+          result = with_spinner(spinner_message) do
+            stdout, stderr, status = Open3.capture3(*args)
+
+            if status.success?
+              # Log output if there is any (for debugging)
+              logger&.debug("Output: #{stdout}") if stdout && !stdout.empty?
+              {success: true, message: "✓"}
+            elsif args.first.to_s.include?("docker")
+              logger&.debug("Error: #{stderr}") if stderr && !stderr.empty?
+              {success: false, message: "✗ (Docker command failed)", raise_error: false}
+            else
+              {success: false, message: "✗", error: "#{command_str} failed: #{stderr}"}
+            end
+          end
+
+          # Handle the case when spinner is disabled
+          if result.is_a?(Hash) && !result[:success] && result[:raise_error] != false
+            raise result[:error]
+          end
+
+          result
+        end
+
+        def system_quiet(*args)
+          require "open3"
+          stdout, _stderr, status = Open3.capture3(*args)
+          logger&.debug("Quietly executed #{args.join(" ")} - success: #{status.success?}")
+          logger&.debug("Output: #{stdout}") if stdout && !stdout.empty? && logger
+          status.success?
+        end
+
+        def ask_to_install(description)
+          unless ENV["QUIET_SETUP"] || ENV["DISABLE_OUTPUT"]
+            puts "You do not currently use #{description}.\n ===> If you want to, type Y\nOtherwise hit any key to ignore."
+          end
+          if gets.chomp == "Y"
+            yield
+          end
+        end
+
+        def proceed_with(task)
+          unless ENV["QUIET_SETUP"] || ENV["DISABLE_OUTPUT"]
+            puts "Proceed with #{task}?\n ===> Type Y to proceed\nOtherwise hit any key to ignore."
+          end
+          if gets.chomp == "Y"
+            yield
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative "base_command"
+
+module Discharger
+  module SetupRunner
+    module Commands
+      class BrewCommand < BaseCommand
+        def execute
+          proceed_with "brew bundle" do
+            log "Ensuring brew dependencies"
+            system! "brew bundle"
+          end
+        end
+
+        def can_execute?
+          File.exist?("Brewfile")
+        end
+
+        def description
+          "Install Homebrew dependencies"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative "base_command"
+
+module Discharger
+  module SetupRunner
+    module Commands
+      class BundlerCommand < BaseCommand
+        def execute
+          log "Installing dependencies"
+          system! "gem install bundler --conservative"
+          system_quiet("bundle check") || system!("bundle install")
+        end
+
+        def can_execute?
+          File.exist?("Gemfile")
+        end
+
+        def description
+          "Install Ruby dependencies"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require_relative "base_command"
+require "fileutils"
+
+module Discharger
+  module SetupRunner
+    module Commands
+      class ConfigCommand < BaseCommand
+        def execute
+          log "Ensuring configuration files are present"
+
+          # Copy database.yml if needed
+          database_yml = File.join(app_root, "config/database.yml")
+          database_yml_example = File.join(app_root, "config/database.yml.example")
+
+          if !File.exist?(database_yml) && File.exist?(database_yml_example)
+            FileUtils.cp(database_yml_example, database_yml)
+            log "Copied config/database.yml.example to config/database.yml"
+          end
+
+          # Copy Procfile.dev to Procfile if needed
+          procfile = File.join(app_root, "Procfile")
+          procfile_dev = File.join(app_root, "Procfile.dev")
+
+          if !File.exist?(procfile) && File.exist?(procfile_dev)
+            FileUtils.cp(procfile_dev, procfile)
+            log "Copied Procfile.dev to Procfile"
+          end
+
+          # Copy any other example config files
+          Dir.glob(File.join(app_root, "config/**/*.example")).each do |example_file|
+            config_file = example_file.sub(/\.example$/, "")
+            unless File.exist?(config_file)
+              FileUtils.cp(example_file, config_file)
+              log "Copied #{example_file.sub(app_root + "/", "")} to #{config_file.sub(app_root + "/", "")}"
+            end
+          end
+        end
+
+        def can_execute?
+          true
+        end
+
+        def description
+          "Setup configuration files"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative "../condition_evaluator"
+
+module Discharger
+  module SetupRunner
+    module Commands
+      class CustomCommand < BaseCommand
+        attr_reader :step_config
+
+        def initialize(config, app_root, logger, step_config)
+          super(config, app_root, logger)
+          @step_config = step_config
+        end
+
+        def execute
+          command = step_config["command"]
+          description = step_config["description"] || command
+          condition = step_config["condition"]
+
+          # Check condition if provided using safe evaluator
+          if condition && !ConditionEvaluator.evaluate(condition)
+            log "Skipping #{description} (condition not met)"
+            return
+          end
+
+          log "Running: #{description}"
+          system!(command)
+        end
+
+        def can_execute?
+          step_config["command"].present?
+        end
+
+        def description
+          step_config["description"] || "Custom command: #{step_config["command"]}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require_relative "base_command"
+require "open3"
+
+module Discharger
+  module SetupRunner
+    module Commands
+      class DatabaseCommand < BaseCommand
+        def execute
+          # 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")
+            if status.success?
+              {success: true}
+            else
+              {success: false, error: "Failed to drop/create database: #{stderr}"}
+            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")
+            if status.success?
+              {success: true}
+            else
+              {success: false, error: "Failed to load schema: #{stderr}"}
+            end
+          end
+
+          # Seed the database
+          env = (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")
+            if status.success?
+              {success: true}
+            else
+              {success: false, error: "Failed to seed database: #{stderr}"}
+            end
+          end
+
+          # 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")
+            if status.success?
+              {success: true}
+            else
+              {success: false, error: "Failed to setup test database: #{stderr}"}
+            end
+          end
+
+          # Clear logs and temp files
+          with_spinner("Clearing logs and temp files") do
+            _stdout, _stderr, status = Open3.capture3("bash", "-c", "bin/rails log:clear tmp:clear > /dev/null 2>&1")
+            if status.success?
+            else
+              # Don't fail for log clearing
+            end
+            {success: true}
+          end
+        end
+
+        def can_execute?
+          File.exist?(File.join(app_root, "bin/rails"))
+        end
+
+        def description
+          "Setup database"
+        end
+
+        private
+
+        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} : {}
+
+          runner_script = <<~RUBY
+            begin
+              # Only proceed if using PostgreSQL
+              if defined?(ActiveRecord::Base) && ActiveRecord::Base.connection.adapter_name =~ /postgresql/i
+                ActiveRecord::Base.connection.execute <<-SQL
+                  SELECT pg_terminate_backend(pid)
+                  FROM pg_stat_activity
+                  WHERE datname = current_database() AND pid <> pg_backend_pid();
+                SQL
+              end
+            rescue => e
+              # If we can't connect or terminate, that's okay - the database might not exist yet
+              # Log error silently in test environment
+              puts "Note: Could not terminate existing connections: \#{e.message}" unless ENV['QUIET_SETUP']
+            end
+          RUBY
+
+          with_spinner("Terminating existing database connections#{rails_env ? " (#{rails_env})" : ""}") do
+            stdout, stderr, status = Open3.capture3(env_vars, "bin/rails", "runner", runner_script)
+
+            if status.success?
+              logger&.debug("Output: #{stdout}") if stdout && !stdout.empty?
+            elsif stderr && !stderr.empty?
+              logger&.debug("Error: #{stderr}")
+              # Don't fail if we can't terminate connections - the database might not exist
+            end
+            {success: true}
+          end
+        end
+      end
+    end
+  end
+end