kettle-dev 1.0.9 → 1.0.10

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,120 @@
+# frozen_string_literal: true
+
+module Kettle
+  module Dev
+    # Minimal Git adapter used by kettle-dev to avoid invoking live shell commands
+    # directly from the library code. In tests, mock this adapter's methods to
+    # prevent any real network or repository mutations.
+    #
+    # This adapter requires the 'git' gem at runtime and does not shell out to
+    # the system git. Specs should stub the git gem API to avoid real pushes.
+    #
+    # 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
+          require "git"
+          @git = ::Git.open(Dir.pwd)
+        rescue LoadError
+          raise Kettle::Dev::Error, "The 'git' gem is required at runtime. Please add it as a dependency."
+        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)
+        # git gem supports force: true option on push
+        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
+      end
+
+      # @return [String, nil] current branch name, or nil on error
+      def current_branch
+        @git.current_branch
+      rescue StandardError
+        nil
+      end
+
+      # @return [Array<String>] list of remote names
+      def remotes
+        @git.remotes.map(&:name)
+      rescue StandardError
+        []
+      end
+
+      # @return [Hash{String=>String}] remote name => fetch URL
+      def remotes_with_urls
+        @git.remotes.each_with_object({}) do |r, h|
+          begin
+            h[r.name] = r.url
+          rescue StandardError
+            # ignore
+          end
+        end
+      rescue StandardError
+        {}
+      end
+
+      # @param name [String]
+      # @return [String, nil]
+      def remote_url(name)
+        r = @git.remotes.find { |x| x.name == name }
+        r&.url
+      rescue StandardError
+        nil
+      end
+
+      # Checkout the given branch
+      # @param branch [String]
+      # @return [Boolean]
+      def checkout(branch)
+        @git.checkout(branch)
+        true
+      rescue StandardError
+        false
+      end
+
+      # Pull from a remote/branch
+      # @param remote [String]
+      # @param branch [String]
+      # @return [Boolean]
+      def pull(remote, branch)
+        @git.pull(remote, branch)
+        true
+      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 ref
+          @git.fetch(remote, ref)
+        else
+          @git.fetch(remote)
+        end
+        true
+      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)
+              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/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"