kettle-dev 1.0.9 → 1.0.11

data/gemfiles/modular/optional.gemfile

@@ -0,0 +1,5 @@
+# Optional dependencies are not dependended on directly, but will be used if present.
+# git gem is not a direct dependency for two reasons:
+# 1. it is incompatible with Truffleruby v23
+# 2. it depends on activesupport, which is too heavy
+gem "git", ">= 1.19.1"    # ruby >= 2.3

data/lib/kettle/dev/ci_helpers.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+# External stdlib
 require "open3"
 require "net/http"
 require "json"

data/lib/kettle/dev/commit_msg.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+# Branch rule enforcement and commit message footer support for commit-msg hook.
+# Provides a lib entrypoint so the exe wrapper can be minimal.
+
+module Kettle
+  module Dev
+    module CommitMsg
+      module_function
+
+      BRANCH_RULES = {
+        "jira" => /^(?<story_type>(hotfix)|(bug)|(feature)|(candy))\/(?<story_id>\d{8,})-.+\Z/,
+      }.freeze
+
+      # Enforce branch rule by appending [type][id] to the commit message when missing.
+      # @param path [String] path to commit message file (ARGV[0] from git)
+      def enforce_branch_rule!(path)
+        validate = ENV.fetch("GIT_HOOK_BRANCH_VALIDATE", "false")
+        branch_rule_type = (!validate.casecmp("false").zero? && validate) || nil
+        return unless branch_rule_type
+        branch_rule = BRANCH_RULES[branch_rule_type]
+        return unless branch_rule
+
+        branch = %x(git branch 2> /dev/null | grep -e ^* | awk '{print $2}')
+        match_data = branch.match(branch_rule)
+        return unless match_data
+
+        commit_msg = File.read(path)
+        unless commit_msg.include?(match_data[:story_id])
+          commit_msg = <<~EOS
+            #{commit_msg.strip}
+            [#{match_data[:story_type]}][#{match_data[:story_id]}]
+          EOS
+          File.open(path, "w") { |file| file.print(commit_msg) }
+        end
+      end
+    end
+  end
+end

data/lib/kettle/dev/exit_adapter.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Kettle
+  module Dev
+    # Exit/abort indirection layer to allow controllable behavior in tests.
+    #
+    # Production/default behavior delegates to Kernel.abort / Kernel.exit,
+    # which raise SystemExit. Specs can stub these methods to avoid terminating
+    # the process or to assert on arguments without coupling to Kernel.
+    #
+    # Example (RSpec):
+    #   allow(Kettle::Dev::ExitAdapter).to receive(:abort).and_raise(SystemExit.new(1))
+    #
+    # This adapter mirrors the "mockable adapter" approach used for GitAdapter.
+    module ExitAdapter
+      module_function
+
+      # Abort the current execution with a message. By default this calls Kernel.abort,
+      # which raises SystemExit after printing the message to STDERR.
+      #
+      # @param msg [String]
+      # @return [void]
+      def abort(msg)
+        Kernel.abort(msg)
+      end
+
+      # Exit the current process with a given status code. By default this calls Kernel.exit.
+      #
+      # @param status [Integer]
+      # @return [void]
+      def exit(status = 0)
+        Kernel.exit(status)
+      end
+    end
+  end
+end

data/lib/kettle/dev/git_adapter.rb

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+require "open3"
+
+module Kettle
+  module Dev
+    # Minimal Git adapter used by kettle-dev to avoid invoking live shell commands
+    # directly from the higher-level library code. In tests, mock this adapter's
+    # methods to prevent any real network or repository mutations.
+    #
+    # Behavior:
+    # - Prefer the 'git' gem when available.
+    # - If the 'git' gem is not present (LoadError), fall back to shelling out to
+    #   the system `git` executable for the small set of operations we need.
+    #
+    # Public API is intentionally small and only includes what we need right now.
+    class GitAdapter
+      # Create a new adapter rooted at the current working directory.
+      # @return [void]
+      def initialize
+        begin
+          # Allow users/CI to opt out of using the 'git' gem even when available.
+          # Set KETTLE_DEV_DISABLE_GIT_GEM to a truthy value ("1", "true", "yes") to force CLI backend.
+          env_val = ENV["KETTLE_DEV_DISABLE_GIT_GEM"]
+          # Ruby 2.3 compatibility: String#match? was added in 2.4; use Regexp#=== / =~ instead
+          disable_gem = env_val && !!(/\A(1|true|yes)\z/i =~ env_val)
+          if disable_gem
+            @backend = :cli
+          else
+            Kernel.require "git"
+            @backend = :gem
+            @git = ::Git.open(Dir.pwd)
+          end
+        rescue LoadError
+          # Optional dependency: fall back to CLI
+          @backend = :cli
+        rescue StandardError => e
+          raise Kettle::Dev::Error, "Failed to open git repository: #{e.message}"
+        end
+      end
+
+      # Push a branch to a remote.
+      # @param remote [String, nil] remote name (nil means default remote)
+      # @param branch [String] branch name (required)
+      # @param force [Boolean] whether to force push
+      # @return [Boolean] true when the push is reported successful
+      def push(remote, branch, force: false)
+        if @backend == :gem
+          begin
+            if remote
+              @git.push(remote, branch, force: force)
+            else
+              # Default remote according to repo config
+              @git.push(nil, branch, force: force)
+            end
+            true
+          rescue StandardError
+            false
+          end
+        else
+          args = ["git", "push"]
+          args << "--force" if force
+          if remote
+            args << remote.to_s << branch.to_s
+          end
+          system(*args)
+        end
+      end
+
+      # @return [String, nil] current branch name, or nil on error
+      def current_branch
+        if @backend == :gem
+          @git.current_branch
+        else
+          out, status = Open3.capture2("git", "rev-parse", "--abbrev-ref", "HEAD")
+          status.success? ? out.strip : nil
+        end
+      rescue StandardError
+        nil
+      end
+
+      # @return [Array<String>] list of remote names
+      def remotes
+        if @backend == :gem
+          @git.remotes.map(&:name)
+        else
+          out, status = Open3.capture2("git", "remote")
+          status.success? ? out.split(/\r?\n/).map(&:strip).reject(&:empty?) : []
+        end
+      rescue StandardError
+        []
+      end
+
+      # @return [Hash{String=>String}] remote name => fetch URL
+      def remotes_with_urls
+        if @backend == :gem
+          @git.remotes.each_with_object({}) do |r, h|
+            begin
+              h[r.name] = r.url
+            rescue StandardError
+              # ignore
+            end
+          end
+        else
+          out, status = Open3.capture2("git", "remote", "-v")
+          return {} unless status.success?
+          urls = {}
+          out.each_line do |line|
+            # Example: origin https://github.com/me/repo.git (fetch)
+            if line =~ /^(\S+)\s+(\S+)\s+\(fetch\)/
+              urls[Regexp.last_match(1)] = Regexp.last_match(2)
+            end
+          end
+          urls
+        end
+      rescue StandardError
+        {}
+      end
+
+      # @param name [String]
+      # @return [String, nil]
+      def remote_url(name)
+        if @backend == :gem
+          r = @git.remotes.find { |x| x.name == name }
+          r&.url
+        else
+          out, status = Open3.capture2("git", "config", "--get", "remote.#{name}.url")
+          status.success? ? out.strip : nil
+        end
+      rescue StandardError
+        nil
+      end
+
+      # Checkout the given branch
+      # @param branch [String]
+      # @return [Boolean]
+      def checkout(branch)
+        if @backend == :gem
+          @git.checkout(branch)
+          true
+        else
+          system("git", "checkout", branch.to_s)
+        end
+      rescue StandardError
+        false
+      end
+
+      # Pull from a remote/branch
+      # @param remote [String]
+      # @param branch [String]
+      # @return [Boolean]
+      def pull(remote, branch)
+        if @backend == :gem
+          @git.pull(remote, branch)
+          true
+        else
+          system("git", "pull", remote.to_s, branch.to_s)
+        end
+      rescue StandardError
+        false
+      end
+
+      # Fetch a ref from a remote (or everything if ref is nil)
+      # @param remote [String]
+      # @param ref [String, nil]
+      # @return [Boolean]
+      def fetch(remote, ref = nil)
+        if @backend == :gem
+          if ref
+            @git.fetch(remote, ref)
+          else
+            @git.fetch(remote)
+          end
+          true
+        elsif ref
+          system("git", "fetch", remote.to_s, ref.to_s)
+        else
+          system("git", "fetch", remote.to_s)
+        end
+      rescue StandardError
+        false
+      end
+    end
+  end
+end

data/lib/kettle/dev/git_commit_footer.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+# Exposed from lib/ so that exe/kettle-commit-msg can be a minimal wrapper.
+
+module Kettle
+  module Dev
+    class GitCommitFooter
+      # Regex to extract `name = "value"` assignments from a gemspec.
+      # @return [Regexp]
+      NAME_ASSIGNMENT_REGEX = /\bname\s*=\s*(["'])([^"']+)\1/.freeze
+
+      # Whether footer appending is enabled (via GIT_HOOK_FOOTER_APPEND=true)
+      # @return [Boolean]
+      FOOTER_APPEND = ENV.fetch("GIT_HOOK_FOOTER_APPEND", "false").casecmp("true").zero?
+      # The sentinel string that must be present to avoid duplicate footers
+      # @return [String, nil]
+      SENTINEL = ENV["GIT_HOOK_FOOTER_SENTINEL"]
+
+      class << self
+        # Resolve git repository top-level dir, or nil outside a repo.
+        # @return [String, nil]
+        def git_toplevel
+          toplevel = nil
+          begin
+            out = %x(git rev-parse --show-toplevel 2>/dev/null)
+            toplevel = out.strip unless out.nil? || out.empty?
+          rescue StandardError
+          end
+          toplevel
+        end
+
+        def local_hooks_dir
+          top = git_toplevel
+          return unless top && !top.empty?
+          File.join(top, ".git-hooks")
+        end
+
+        def global_hooks_dir
+          File.join(ENV["HOME"], ".git-hooks")
+        end
+
+        def hooks_path_for(filename)
+          local_dir = local_hooks_dir
+          if local_dir
+            local_path = File.join(local_dir, filename)
+            return local_path if File.file?(local_path)
+          end
+          File.join(global_hooks_dir, filename)
+        end
+
+        def commit_goalie_path
+          hooks_path_for("commit-subjects-goalie.txt")
+        end
+
+        def goalie_allows_footer?(subject_line)
+          goalie_path = commit_goalie_path
+          return false unless File.file?(goalie_path)
+
+          prefixes = File.read(goalie_path).lines.map { |l| l.strip }.reject { |l| l.empty? || l.start_with?("#") }
+          return false if prefixes.empty?
+
+          subj = subject_line.to_s.strip
+          prefixes.any? { |prefix| subj.start_with?(prefix) }
+        end
+
+        def render(*argv)
+          commit_msg = File.read(argv[0])
+          subject_line = commit_msg.lines.first.to_s
+
+          # Evaluate configuration at runtime to respect ENV set during tests/CI
+          footer_append = ENV.fetch("GIT_HOOK_FOOTER_APPEND", "false").casecmp("true").zero?
+          sentinel = ENV["GIT_HOOK_FOOTER_SENTINEL"]
+
+          if footer_append && (sentinel.nil? || sentinel.to_s.empty?)
+            raise "Set GIT_HOOK_FOOTER_SENTINEL=<footer sentinel> in .env.local (e.g., '⚡️ A message from a fellow meat-based-AI ⚡️')"
+          end
+
+          if footer_append && goalie_allows_footer?(subject_line)
+            if commit_msg.include?(sentinel)
+              Kettle::Dev::ExitAdapter.exit(0)
+            else
+              footer_binding = GitCommitFooter.new
+              File.open(argv[0], "w") do |file|
+                file.print(commit_msg)
+                file.print("\n")
+                file.print(footer_binding.render)
+              end
+            end
+          else
+            # Skipping footer append
+          end
+        end
+      end
+
+      def initialize
+        @pwd = Dir.pwd
+        @gemspecs = Dir["*.gemspec"]
+        @spec = @gemspecs.first
+        @gemspec_path = File.expand_path(@spec, @pwd)
+        @gem_name = parse_gemspec_name || derive_gem_name
+      end
+
+      def render
+        ERB.new(template).result(binding)
+      end
+
+      private
+
+      def parse_gemspec_name
+        begin
+          content = File.read(@gemspec_path)
+          @name_index = content =~ NAME_ASSIGNMENT_REGEX
+          if @name_index
+            return $2
+          end
+        rescue StandardError
+        end
+        nil
+      end
+
+      def derive_gem_name
+        File.basename(@gemspec_path, ".*") if @gemspec_path
+      end
+
+      def template
+        File.read(self.class.hooks_path_for("footer-template.erb.txt"))
+      end
+    end
+  end
+end

data/lib/kettle/dev/input_adapter.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Kettle
+  module Dev
+    # Input indirection layer to make interactive prompts safe in tests.
+    #
+    # Production/default behavior delegates to $stdin.gets (or Kernel#gets)
+    # so application code does not read from STDIN directly. In specs, mock
+    # this adapter's methods to return deterministic answers without touching
+    # global IO.
+    #
+    # Example (RSpec):
+    #   allow(Kettle::Dev::InputAdapter).to receive(:gets).and_return("y\n")
+    #
+    # This mirrors the "mockable adapter" approach used for GitAdapter and ExitAdapter.
+    module InputAdapter
+      module_function
+
+      # Read one line from the standard input, including the trailing newline if
+      # present. Returns nil on EOF, consistent with IO#gets.
+      #
+      # @param args [Array] any args are forwarded to $stdin.gets for compatibility
+      # @return [String, nil]
+      def gets(*args)
+        $stdin.gets(*args)
+      end
+
+      # Read one line from standard input, raising EOFError on end-of-file.
+      # Provided for convenience symmetry with IO#readline when needed.
+      #
+      # @param args [Array]
+      # @return [String]
+      def readline(*args)
+        line = gets(*args)
+        raise EOFError, "end of file reached" if line.nil?
+        line
+      end
+    end
+  end
+end

data/lib/kettle/dev/rakelib/appraisal.rake

@@ -1,9 +1,4 @@
-begin
-  require "bundler"
-rescue LoadError
-  warn("[kettle-dev][appraisal.rake] failed to load bundler") if Kettle::Dev::DEBUGGING
-  # ok, might still work
-end
+# frozen_string_literal: true
 
 # --- Appraisals (dev-only) ---
 begin
@@ -16,15 +11,19 @@ begin
     run_in_unbundled = proc do
       env = {"BUNDLE_GEMFILE" => "Appraisal.root.gemfile"}
 
-      # 1) BUNDLE_GEMFILE=Appraisal.root.gemfile bundle
+      # 1) BUNDLE_GEMFILE=Appraisal.root.gemfile bundle update --bundler
+      ok = system(env, bundle, "update", "--bundler")
+      abort("appraisal:update failed: bundle update --bundler under Appraisal.root.gemfile") unless ok
+
+      # 2) BUNDLE_GEMFILE=Appraisal.root.gemfile bundle (install)
       ok = system(env, bundle)
       abort("appraisal:update failed: bundler install under Appraisal.root.gemfile") unless ok
 
-      # 2) BUNDLE_GEMFILE=Appraisal.root.gemfile bundle exec appraisal update
+      # 3) BUNDLE_GEMFILE=Appraisal.root.gemfile bundle exec appraisal update
       ok = system(env, bundle, "exec", "appraisal", "update")
       abort("appraisal:update failed: bundle exec appraisal update") unless ok
 
-      # 3) bundle exec rake rubocop_gradual:autocorrect
+      # 4) bundle exec rake rubocop_gradual:autocorrect
       ok = system(bundle, "exec", "rake", "rubocop_gradual:autocorrect")
       abort("appraisal:update failed: rubocop_gradual:autocorrect") unless ok
     end

data/lib/kettle/dev/rakelib/bench.rake

@@ -1,11 +1,6 @@
-require "rbconfig" if !Dir[File.join(__dir__, "benchmarks")].empty? # Used by `rake bench:run`
+# frozen_string_literal: true
 
-begin
-  require "bundler"
-rescue LoadError
-  warn("[kettle-dev][bench.rake] failed to load bundler") if Kettle::Dev::DEBUGGING
-  # ok, might still work
-end
+require "rbconfig" if !Dir[File.join(__dir__, "benchmarks")].empty? # Used by `rake bench:run`
 
 # --- Benchmarks (dev-only) ---
 namespace :bench do

data/lib/kettle/dev/rakelib/bundle_audit.rake

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Setup Bundle Audit
 begin
   require "bundler/audit/task"