kettle-dev 1.0.10 → 1.0.11

data/lib/kettle/dev/git_adapter.rb

@@ -1,13 +1,17 @@
 # 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 library code. In tests, mock this adapter's methods to
-    # prevent any real network or repository mutations.
+    # directly from the higher-level 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.
+    # 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
@@ -15,10 +19,21 @@ module Kettle
       # @return [void]
       def initialize
         begin
-          require "git"
-          @git = ::Git.open(Dir.pwd)
+          # 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
-          raise Kettle::Dev::Error, "The 'git' gem is required at runtime. Please add it as a dependency."
+          # Optional dependency: fall back to CLI
+          @backend = :cli
         rescue StandardError => e
           raise Kettle::Dev::Error, "Failed to open git repository: #{e.message}"
         end
@@ -30,42 +45,73 @@ module Kettle
       # @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 @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
-            @git.push(remote, branch, force: force)
-          else
-            # Default remote according to repo config
-            @git.push(nil, branch, force: force)
+            args << remote.to_s << branch.to_s
           end
-          true
-        rescue StandardError
-          false
+          system(*args)
         end
       end
 
       # @return [String, nil] current branch name, or nil on error
       def current_branch
-        @git.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
-        @git.remotes.map(&:name)
+        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
-        @git.remotes.each_with_object({}) do |r, h|
-          begin
-            h[r.name] = r.url
-          rescue StandardError
-            # ignore
+        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
         {}
@@ -74,8 +120,13 @@ module Kettle
       # @param name [String]
       # @return [String, nil]
       def remote_url(name)
-        r = @git.remotes.find { |x| x.name == name }
-        r&.url
+        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
@@ -84,8 +135,12 @@ module Kettle
       # @param branch [String]
       # @return [Boolean]
       def checkout(branch)
-        @git.checkout(branch)
-        true
+        if @backend == :gem
+          @git.checkout(branch)
+          true
+        else
+          system("git", "checkout", branch.to_s)
+        end
       rescue StandardError
         false
       end
@@ -95,8 +150,12 @@ module Kettle
       # @param branch [String]
       # @return [Boolean]
       def pull(remote, branch)
-        @git.pull(remote, branch)
-        true
+        if @backend == :gem
+          @git.pull(remote, branch)
+          true
+        else
+          system("git", "pull", remote.to_s, branch.to_s)
+        end
       rescue StandardError
         false
       end
@@ -106,12 +165,18 @@ module Kettle
       # @param ref [String, nil]
       # @return [Boolean]
       def fetch(remote, ref = nil)
-        if ref
-          @git.fetch(remote, ref)
+        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
-          @git.fetch(remote)
+          system("git", "fetch", remote.to_s)
         end
-        true
       rescue StandardError
         false
       end

data/lib/kettle/dev/git_commit_footer.rb

@@ -77,7 +77,7 @@ module Kettle
 
           if footer_append && goalie_allows_footer?(subject_line)
             if commit_msg.include?(sentinel)
-              exit(0)
+              Kettle::Dev::ExitAdapter.exit(0)
             else
               footer_binding = GitCommitFooter.new
               File.open(argv[0], "w") do |file|

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/release_cli.rb

@@ -16,6 +16,8 @@ require "ruby-progressbar"
 # Internal
 require "kettle/dev/git_adapter"
 require "kettle/dev/exit_adapter"
+require "kettle/dev/input_adapter"
+require "kettle/dev/versioning"
 
 module Kettle
   module Dev
@@ -34,8 +36,6 @@ module Kettle
       end
 
       def run
-        puts "== kettle-release =="
-
         ensure_bundler_2_7_plus!
 
         version = detect_version
@@ -68,11 +68,23 @@ module Kettle
           else
             latest_overall
           end
-          if target && Gem::Version.new(version) <= Gem::Version.new(target)
-            series = cur_series.join(".")
-            warn("version.rb (#{version}) must be greater than the latest released version for series #{series}. Latest for series: #{target}.")
-            warn("Tip: bump PATCH for a stable branch release, or bump MINOR/MAJOR when on trunk.")
-            abort("Aborting: version bump required.")
+          if target
+            bump = Kettle::Dev::Versioning.classify_bump(target, version)
+            case bump
+            when :same
+              series = cur_series.join(".")
+              warn("version.rb (#{version}) matches the latest released version for series #{series} (#{target}).")
+              abort("Aborting: version bump required. Bump PATCH/MINOR/MAJOR/EPIC.")
+            when :downgrade
+              series = cur_series.join(".")
+              warn("version.rb (#{version}) is lower than the latest released version for series #{series} (#{target}).")
+              abort("Aborting: version must be bumped above #{target}.")
+            else
+              label = {epic: "EPIC", major: "MAJOR", minor: "MINOR", patch: "PATCH"}[bump] || bump.to_s.upcase
+              puts "Proposed bump type: #{label} (from #{target} -> #{version})"
+            end
+          else
+            puts "Could not determine latest released version from RubyGems (offline?). Proceeding without sanity check."
           end
         else
           puts "Could not determine latest released version from RubyGems (offline?). Proceeding without sanity check."
@@ -80,7 +92,7 @@ module Kettle
 
         puts "Have you updated lib/**/version.rb and CHANGELOG.md for v#{version}? [y/N]"
         print("> ")
-        ans = $stdin.gets&.strip
+        ans = Kettle::Dev::InputAdapter.gets&.strip
         abort("Aborted: please update version.rb and CHANGELOG.md, then re-run.") unless ans&.downcase&.start_with?("y")
 
         run_cmd!("bin/setup")
@@ -119,7 +131,7 @@ module Kettle
           # Prompt on CI to allow an explicit abort when signing would otherwise hang
           if ENV.fetch("CI", "false").casecmp("true").zero?
             print("Proceed with signing enabled? This may hang waiting for a PEM password. [y/N]: ")
-            ans = $stdin.gets&.strip
+            ans = Kettle::Dev::InputAdapter.gets&.strip
             unless ans&.downcase&.start_with?("y")
               abort("Aborted. Re-run with SKIP_GEM_SIGNING=true bundle exec kettle-release (or set it in your environment).")
             end
@@ -269,7 +281,7 @@ module Kettle
         when "true", "1", "yes", "y" then true
         when "ask"
           print("Run local CI with 'act' before pushing? [Y/n] ")
-          ans = $stdin.gets&.strip
+          ans = Kettle::Dev::InputAdapter.gets&.strip
           ans.nil? || ans.empty? || ans =~ /\Ay(es)?\z/i
         else
           false
@@ -329,17 +341,7 @@ module Kettle
       end
 
       def detect_version
-        candidates = Dir[File.join(@root, "lib", "**", "version.rb")]
-        abort("Could not find version.rb under lib/**.") if candidates.empty?
-        versions = candidates.map do |path|
-          content = File.read(path)
-          m = content.match(/VERSION\s*=\s*(["'])([^"']+)\1/)
-          next unless m
-          m[2]
-        end.compact
-        abort("VERSION constant not found in #{@root}/lib/**/version.rb") if versions.none?
-        abort("Multiple VERSION constants found to be out of sync (#{versions.inspect}) in #{@root}/lib/**/version.rb") unless versions.uniq.length == 1
-        versions.first
+        Kettle::Dev::Versioning.detect_version(@root)
       end
 
       def detect_gem_name
@@ -571,7 +573,7 @@ module Kettle
             puts "  [m] Merge --no-ff #{gh_remote}/#{trunk} into #{trunk} (push to origin and #{gh_remote})"
             puts "  [a] Abort"
             print("> ")
-            choice = $stdin.gets&.strip&.downcase
+            choice = Kettle::Dev::InputAdapter.gets&.strip&.downcase
             case choice
             when "r"
               run_cmd!("git rebase #{Shellwords.escape("#{gh_remote}/#{trunk}")}")

data/lib/kettle/dev/tasks/ci_task.rb

@@ -2,6 +2,7 @@
 
 # External
 require "kettle/dev/exit_adapter"
+require "kettle/dev/input_adapter"
 require "open3"
 require "net/http"
 require "json"
@@ -188,7 +189,7 @@ module Kettle
           selected = nil
           input_thread = Thread.new do
             begin
-              selected = $stdin.gets&.strip
+              selected = Kettle::Dev::InputAdapter.gets&.strip
             rescue Exception => error
               # Catch all exceptions in background thread, including SystemExit
               # NOTE: look into refactoring to minimize potential SystemExit.
@@ -249,8 +250,10 @@ module Kettle
                   sleep(poll_interval)
                 end
               rescue Exception
+                # :nocov:
                 # Catch all exceptions in the worker thread boundary, including SystemExit
                 status_q << [c, f, "err"]
+                # :nocov:
               end
             end
           end