discharger 0.2.10 → 0.2.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 123fc77a1effa1f7cd70e68b9056cfb9d9491069edafca3939b40c092cf580fd
-  data.tar.gz: 9800b64540311c15e0805d835e6f137e39b5751a932ee3106406743b21353d8e
+  metadata.gz: 0556c953dac93a704d652f69824bd24da384f42c204487340512beafde360f95
+  data.tar.gz: f3224ed2f8bc399bc7a9e33014334843058a4e44540fc8a14e34fa47091611d5
 SHA512:
-  metadata.gz: f840bfaf4c5db5c4321263d968d7fda42388d978fa49571bf78be219b64afcd52b9e06e870fe6d33fdd54b417104d1646dbbed4bf77ab42c154ff851d68da96c
-  data.tar.gz: 6dc97ddbfe29459973e3d2eaee4fa299c644112b5d0a3c3c65d566015c7018ba3ae4c0da0265781fc3d6785c0bbfe38bca0bdacbede5584646cafdaa09dff8bc
+  metadata.gz: 33ace7f51a07a0c126ba03285cde6695bdb5b38a84b796ca1588a16695dac532f9222340ca683ed5b2b7ae5e61d1abc3704f444db15ee2ba73a60f6e2e95f6a4
+  data.tar.gz: f0c3821be4631d3a804a71f68df53a56b7788f7d56598361d540027b7118f79466ba8e82a082ddac1bd2c124c8e4002f37e5f5cb3aa8da62ffbe7a4da97ee842

data/README.md

@@ -1,26 +1,80 @@
 # Discharger
-Code supporting tasks that discharge code for deployment.
 
-## Usage
+A Ruby gem that provides Rake tasks for managing code deployment workflows with automated versioning, changelog management, and Slack notifications.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem "discharger"
+```
+
+And then execute:
+```bash
+$ bundle install
+```
+
+Then run the install generator:
+```bash
+$ rails generate discharger:install
+```
 
-Add `require "discharger/task"` to your Rakefile.
+Or install it yourself as:
+```bash
+$ gem install discharger
+```
 
-Then build the discharger task
+## Usage
+
+Add `require "discharger/task"` to your Rakefile, then configure the discharger task:
 
 ```ruby
 require "discharger/task"
 
 Discharger::Task.create do |task|
+  # Version management
   task.version_file = "config/application.rb"
-  task.release_message_channel = "#some-slack-channel"
   task.version_constant = "MyApp::VERSION"
-  task.app_name = "My App name"
+  
+  # Slack integration
+  task.release_message_channel = "#some-slack-channel"
+  task.app_name = "My App Name"
+  
+  # Git integration
   task.commit_identifier = -> { `git rev-parse HEAD`.strip }
   task.pull_request_url = "https://github.com/SOFware/some-app"
+  
+  # Changelog management (optional)
+  task.fragment_directory = "changelog.d"  # Directory for changelog fragments
+end
+```
+
+### Changelog Fragments
+
+Discharger supports changelog fragment management through the `fragment_directory` setting. When set, Discharger will look for changelog fragments in the specified directory and automatically combine them into the main changelog during releases.
+
+```ruby
+Discharger::Task.create do |task|
+  # ... other configuration ...
+  task.fragment_directory = "changelog.d"  # Default: nil (disabled)
 end
 ```
 
-It will make Rake tasks available to push code to branches and notify Slack channels.
+With fragments enabled, you can create individual changelog files in the `changelog.d/` directory:
+
+```
+changelog.d/
+├── 123-fix-login-bug.md
+├── 124-add-user-profile.md
+└── 125-update-dependencies.md
+```
+
+Each fragment file should contain the changelog entry for a specific change or feature.
+
+## Available Tasks
+
+The gem creates several Rake tasks for managing your deployment workflow:
 
 ```bash
 $ rake -T release
@@ -32,33 +86,28 @@ rake release:slack[text,channel,emoji]  # Send a message to Slack
 rake release:stage                      # ---------- STEP 2 ----------
 ```
 
-## Installation
-Add this line to your application's Gemfile:
+### Workflow Steps
 
-```ruby
-gem "discharger"
-```
+1. **Prepare** (`rake release:prepare`): Create a new branch to prepare the release, update the changelog, and bump the version
+2. **Stage** (`rake release:stage`): Update the staging branch and create a PR to production
+3. **Release** (`rake release`): Release the current version to production by tagging and pushing to the production branch
 
-And then execute:
-```bash
-$ bundle
-```
+## Contributing
 
-Then run the install generator:
-```bash
-$ rails generate discharger:install
-```
+This gem is managed with [Reissue](https://github.com/SOFware/reissue).
 
-Or install it yourself as:
-```bash
-$ gem install discharger
-```
+### Releasing
 
-## Contributing
+Releases are automated via GitHub Actions:
 
-This gem is managed with [Reissue](https://github.com/SOFware/reissue).
+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
+
 The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

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