kettle-dev 1.0.26 → 1.1.0

data/kettle-dev.gemspec.example

@@ -116,5 +116,51 @@ Gem::Specification.new do |spec|
   #       and preferably a modular one (see gemfiles/modular/*.gemfile).
 
   # Dev, Test, & Release Tasks
-  spec.add_development_dependency("{KETTLE|DEV|GEM}", "~> 1.0.17")            # ruby >= 2.3.0
+  spec.add_development_dependency("{KETTLE|DEV|GEM}", "~> 1.0")            # ruby >= 2.3.0
+
+  # Security
+  spec.add_development_dependency("bundler-audit", "~> 0.9.2")                      # ruby >= 2.0.0
+
+  # Tasks
+  spec.add_development_dependency("rake", "~> 13.0")                                # ruby >= 2.2.0
+
+  # Debugging
+  spec.add_development_dependency("require_bench", "~> 1.0", ">= 1.0.4")            # ruby >= 2.2.0
+
+  # Testing
+  spec.add_development_dependency("appraisal2", "~> 3.0")                           # ruby >= 1.8.7, for testing against multiple versions of dependencies
+  spec.add_development_dependency("kettle-test", "~> 1.0")                          # ruby >= 2.3
+  spec.add_development_dependency("rspec-pending_for")                                # ruby >= 2.3, used to skip specs on incompatible Rubies
+
+  # Releasing
+  spec.add_development_dependency("ruby-progressbar", "~> 1.13")                    # ruby >= 0
+  spec.add_development_dependency("stone_checksums", "~> 1.0", ">= 1.0.2")          # ruby >= 2.2.0
+
+  # Git integration (optional)
+  # The 'git' gem is optional; kettle-dev falls back to shelling out to `git` if it is not present.
+  # The current release of the git gem depends on activesupport, which makes it too heavy to depend on directly
+  # spec.add_dependency("git", ">= 1.19.1")                               # ruby >= 2.3
+
+  # Development tasks
+  # The cake is a lie. erb v2.2, the oldest release on RubyGems.org, was never compatible with Ruby 2.3.
+  # This means we have no choice but to use the erb that shipped with Ruby 2.3
+  # /opt/hostedtoolcache/Ruby/2.3.8/x64/lib/ruby/gems/2.3.0/gems/erb-2.2.2/lib/erb.rb:670:in `prepare_trim_mode': undefined method `match?' for "-":String (NoMethodError)
+  # spec.add_development_dependency("erb", ">= 2.2")                                  # ruby >= 2.3.0, not SemVer, old rubies get dropped in a patch.
+  spec.add_development_dependency("gitmoji-regex", "~> 1.0", ">= 1.0.3")            # ruby >= 2.3.0
+
+  # HTTP recording for deterministic specs
+  # It seems that somehow just having a newer version of appraisal installed breaks
+  #   Ruby 2.3 and 2.4 even if their bundle specifies an older version,
+  #   and as a result it can only be a dependency in the appraisals.
+  # | An error occurred while loading spec_helper.
+  # | Failure/Error: require "vcr"
+  # |
+  # | NoMethodError:
+  # |   undefined method `delete_prefix' for "CONTENT_LENGTH":String
+  # | # ./spec/config/vcr.rb:3:in `require'
+  # | # ./spec/config/vcr.rb:3:in `<top (required)>'
+  # | # ./spec/spec_helper.rb:8:in `require_relative'
+  # | # ./spec/spec_helper.rb:8:in `<top (required)>'
+  # spec.add_development_dependency("vcr", ">= 4")                      # 6.0 claims to support ruby >= 2.3, but fails on ruby 2.4
+  # spec.add_development_dependency("webmock", ">= 3")               # Last version to support ruby >= 2.3
 end

data/lib/kettle/dev/git_adapter.rb

@@ -15,6 +15,27 @@ module Kettle
     #
     # Public API is intentionally small and only includes what we need right now.
     class GitAdapter
+      # Determine whether the working tree is clean (no unstaged, staged, or untracked changes).
+      # @return [Boolean] true if clean, false if any changes or on error
+      def clean?
+        if @backend == :gem
+          begin
+            status = @git.status
+            # git gem's Status responds to changed, added, deleted, untracked, etc.
+            status.changed.empty? && status.added.empty? && status.deleted.empty? && status.untracked.empty?
+          rescue StandardError => e
+            Kettle::Dev.debug_error(e, __method__)
+            false
+          end
+        else
+          out, st = Open3.capture2("git", "status", "--porcelain")
+          st.success? && out.strip.empty?
+        end
+      rescue StandardError => e
+        Kettle::Dev.debug_error(e, __method__)
+        false
+      end
+
       # Execute a git command and capture its stdout and success flag.
       # This is a generic escape hatch used by higher-level code for read-only
       # queries that aren't covered by the explicit adapter API. Tests can stub
@@ -24,7 +45,8 @@ module Kettle
       def capture(args)
         out, status = Open3.capture2("git", *args)
         [out.strip, status.success?]
-      rescue StandardError
+      rescue StandardError => e
+        Kettle::Dev.debug_error(e, __method__)
         ["", false]
       end
 
@@ -44,7 +66,8 @@ module Kettle
             @backend = :gem
             @git = ::Git.open(Dir.pwd)
           end
-        rescue LoadError
+        rescue LoadError => e
+          Kettle::Dev.debug_error(e, __method__)
           # Optional dependency: fall back to CLI
           @backend = :cli
         rescue StandardError => e
@@ -67,7 +90,8 @@ module Kettle
               @git.push(nil, branch, force: force)
             end
             true
-          rescue StandardError
+          rescue StandardError => e
+            Kettle::Dev.debug_error(e, __method__)
             false
           end
         else
@@ -88,7 +112,8 @@ module Kettle
           out, status = Open3.capture2("git", "rev-parse", "--abbrev-ref", "HEAD")
           status.success? ? out.strip : nil
         end
-      rescue StandardError
+      rescue StandardError => e
+        Kettle::Dev.debug_error(e, __method__)
         nil
       end
 
@@ -100,7 +125,8 @@ module Kettle
           out, status = Open3.capture2("git", "remote")
           status.success? ? out.split(/\r?\n/).map(&:strip).reject(&:empty?) : []
         end
-      rescue StandardError
+      rescue StandardError => e
+        Kettle::Dev.debug_error(e, __method__)
         []
       end
 
@@ -110,7 +136,8 @@ module Kettle
           @git.remotes.each_with_object({}) do |r, h|
             begin
               h[r.name] = r.url
-            rescue StandardError
+            rescue StandardError => e
+              Kettle::Dev.debug_error(e, __method__)
               # ignore
             end
           end
@@ -126,7 +153,8 @@ module Kettle
           end
           urls
         end
-      rescue StandardError
+      rescue StandardError => e
+        Kettle::Dev.debug_error(e, __method__)
         {}
       end
 
@@ -140,7 +168,8 @@ module Kettle
           out, status = Open3.capture2("git", "config", "--get", "remote.#{name}.url")
           status.success? ? out.strip : nil
         end
-      rescue StandardError
+      rescue StandardError => e
+        Kettle::Dev.debug_error(e, __method__)
         nil
       end
 

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

@@ -136,6 +136,7 @@ module Kettle
               end
             end
           rescue StandardError => e
+            Kettle::Dev.debug_error(e, __method__)
             puts "WARNING: Skipped trimming MRI Ruby badges in README.md due to #{e.class}: #{e.message}"
           end
 
@@ -159,7 +160,8 @@ module Kettle
                     cluster = tail[/\A\X/u]
                     chosen_grapheme = cluster unless cluster.to_s.empty?
                   end
-                rescue StandardError
+                rescue StandardError => e
+                  Kettle::Dev.debug_error(e, __method__)
                   # Fallback: take first Unicode grapheme if any non-space char
                   chosen_grapheme ||= tail[/\A\X/u]
                 end
@@ -200,7 +202,8 @@ module Kettle
                     new_readme = lines.join("\n")
                     File.open(readme_path, "w") { |f| f.write(new_readme) }
                   end
-                rescue StandardError
+                rescue StandardError => e
+                  Kettle::Dev.debug_error(e, __method__)
                   # ignore README normalization errors
                 end
 
@@ -237,7 +240,8 @@ module Kettle
                   if gspec3 != gspec
                     File.open(gemspec_path, "w") { |f| f.write(gspec3) }
                   end
-                rescue StandardError
+                rescue StandardError => e
+                  Kettle::Dev.debug_error(e, __method__)
                   # ignore gemspec edits on error
                 end
               end

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

@@ -134,7 +134,8 @@ module Kettle
                     new_constraint = ruby1_8[1]
                     rubocop_ruby_gem_version = ruby1_8[0].segments.join("_")
                   end
-                rescue StandardError
+                rescue StandardError => e
+                  Kettle::Dev.debug_error(e, __method__)
                   # ignore, use default
                 ensure
                   new_constraint ||= ruby1_8[1]
@@ -178,6 +179,7 @@ module Kettle
               helpers.copy_file_with_prompt(envlocal_src, envlocal_dest, allow_create: true, allow_replace: true)
             end
           rescue StandardError => e
+            Kettle::Dev.debug_error(e, __method__)
             puts "WARNING: Skipped .env.local example copy due to #{e.class}: #{e.message}"
           end
 
@@ -303,7 +305,8 @@ module Kettle
                     unless exes.empty?
                       c = replace_array_field.call(c, "executables", exes)
                     end
-                  rescue StandardError
+                  rescue StandardError => e
+                    Kettle::Dev.debug_error(e, __method__)
                     # Best-effort carry-over; ignore any individual failure
                   end
                 end
@@ -384,7 +387,8 @@ module Kettle
                     end
                   end
                 end
-              rescue StandardError
+              rescue StandardError => e
+                Kettle::Dev.debug_error(e, __method__)
                 # ignore, leave dest_preserve_prefix as nil
               end
 
@@ -520,10 +524,12 @@ module Kettle
                         end
                       end
                     end
-                  rescue StandardError
+                  rescue StandardError => e
+                    Kettle::Dev.debug_error(e, __method__)
                     # ignore H1 preservation errors
                   end
-                rescue StandardError
+                rescue StandardError => e
+                  Kettle::Dev.debug_error(e, __method__)
                   # Best effort; if anything fails, keep c as-is
                 end
 

data/lib/kettle/dev/template_helpers.rb

@@ -104,22 +104,45 @@ module Kettle
       def ensure_clean_git!(root:, task_label:)
         inside_repo = begin
           system("git", "-C", root.to_s, "rev-parse", "--is-inside-work-tree", out: File::NULL, err: File::NULL)
-        rescue StandardError
+        rescue StandardError => e
+          Kettle::Dev.debug_error(e, __method__)
           false
         end
         return unless inside_repo
 
-        status_output = begin
-          IO.popen(["git", "-C", root.to_s, "status", "--porcelain"], &:read).to_s
-        rescue StandardError
-          ""
+        # Prefer GitAdapter for cleanliness check; fallback to porcelain output
+        clean = begin
+          Dir.chdir(root.to_s) { Kettle::Dev::GitAdapter.new.clean? }
+        rescue StandardError => e
+          Kettle::Dev.debug_error(e, __method__)
+          nil
+        end
+
+        if clean.nil?
+          # Fallback to shelling out to get both status and preview
+          status_output = begin
+            IO.popen(["git", "-C", root.to_s, "status", "--porcelain"], &:read).to_s
+          rescue StandardError => e
+            Kettle::Dev.debug_error(e, __method__)
+            ""
+          end
+          return if status_output.strip.empty?
+          preview = status_output.lines.take(10).map(&:rstrip)
+        else
+          return if clean
+          # For messaging, provide a small preview via porcelain even when using the adapter
+          status_output = begin
+            IO.popen(["git", "-C", root.to_s, "status", "--porcelain"], &:read).to_s
+          rescue StandardError => e
+            Kettle::Dev.debug_error(e, __method__)
+            ""
+          end
+          preview = status_output.lines.take(10).map(&:rstrip)
         end
-        return if status_output.strip.empty?
 
         puts "ERROR: Your git working tree has uncommitted changes."
         puts "#{task_label} may modify files (e.g., .github/, .gitignore, *.gemspec)."
         puts "Please commit or stash your changes, then re-run: rake #{task_label}"
-        preview = status_output.lines.take(10).map(&:rstrip)
         unless preview.empty?
           puts "Detected changes:"
           preview.each { |l| puts "  #{l}" }
@@ -162,7 +185,8 @@ module Kettle
               end
             end
           end
-        rescue StandardError
+        rescue StandardError => e
+          Kettle::Dev.debug_error(e, __method__)
           # If anything goes wrong parsing/matching, ignore the filter and proceed.
         end
 
@@ -192,7 +216,8 @@ module Kettle
         begin
           token = "{KETTLE|DEV|GEM}"
           content = content.gsub(token, "kettle-dev") if content.include?(token)
-        rescue StandardError
+        rescue StandardError => e
+          Kettle::Dev.debug_error(e, __method__)
           # If replacement fails unexpectedly, proceed with content as-is
         end
         write_file(dest_path, content)
@@ -227,7 +252,8 @@ module Kettle
                 File.fnmatch?(pat, rel_dest, File::FNM_PATHNAME | File::FNM_EXTGLOB | File::FNM_DOTMATCH)
               end
             end
-          rescue StandardError
+          rescue StandardError => e
+            Kettle::Dev.debug_error(e, __method__)
             # On any error, do not filter out (act as matched)
             true
           end
@@ -253,7 +279,8 @@ module Kettle
               return
             end
           end
-        rescue StandardError
+        rescue StandardError => e
+          Kettle::Dev.debug_error(e, __method__)
           # If determining matches fails, fall through to prompting logic
         end
 
@@ -283,7 +310,8 @@ module Kettle
                       File.open(target, "wb") { |f| f.write(data) }
                       next
                     end
-                  rescue StandardError
+                  rescue StandardError => e
+                    Kettle::Dev.debug_error(e, __method__)
                     # ignore compare errors; fall through to copy
                   end
                 end
@@ -320,7 +348,8 @@ module Kettle
                     File.open(target, "wb") { |f| f.write(data) }
                     next
                   end
-                rescue StandardError
+                rescue StandardError => e
+                  Kettle::Dev.debug_error(e, __method__)
                   # ignore compare errors; fall through to copy
                 end
               end

data/lib/kettle/dev/version.rb

@@ -6,7 +6,90 @@ module Kettle
     module Version
       # The gem version.
       # @return [String]
-      VERSION = "1.0.26"
+      VERSION = "1.1.0"
+
+      module_function
+
+      # rubocop:disable ThreadSafety/ClassInstanceVariable
+      #
+      # The logic below, through the end of the file, comes from version_gem.
+      # Extracted because version_gem depends on this gem, and circular dependencies are bad.
+      #
+      # A Gem::Version for this version string
+      #
+      # Useful when you need to compare versions or pass a Gem::Version instance
+      # to APIs that expect it. This is equivalent to `Gem::Version.new(to_s)`.
+      #
+      # @return [Gem::Version]
+      def gem_version
+        @gem_version ||= ::Gem::Version.new(to_s)
+      end
+
+      # The version number as a string
+      #
+      # @return [String]
+      def to_s
+        self::VERSION
+      end
+
+      # The major version
+      #
+      # @return [Integer]
+      def major
+        @major ||= _to_a[0].to_i
+      end
+
+      # The minor version
+      #
+      # @return [Integer]
+      def minor
+        @minor ||= _to_a[1].to_i
+      end
+
+      # The patch version
+      #
+      # @return [Integer]
+      def patch
+        @patch ||= _to_a[2].to_i
+      end
+
+      # The pre-release version, if any
+      #
+      # @return [String, NilClass]
+      def pre
+        @pre ||= _to_a[3]
+      end
+
+      # The version number as a hash
+      #
+      # @return [Hash]
+      def to_h
+        @to_h ||= {
+          major: major,
+          minor: minor,
+          patch: patch,
+          pre: pre,
+        }
+      end
+
+      # The version number as an array of cast values
+      #
+      # @return [Array<[Integer, String, NilClass]>]
+      def to_a
+        @to_a ||= [major, minor, patch, pre]
+      end
+
+      private
+
+      module_function
+
+      # The version number as an array of strings
+      #
+      # @return [Array<String>]
+      def _to_a
+        @_to_a = self::VERSION.split(".")
+      end
+      # rubocop:enable ThreadSafety/ClassInstanceVariable
     end
   end
 end

data/lib/kettle/dev.rb

@@ -5,31 +5,71 @@
 # :nocov:
 require "require_bench" if ENV.fetch("REQUIRE_BENCH", "false").casecmp("true").zero?
 # :nocov:
-require "version_gem"
 
+# Autoload public CLI/APIs so requiring "kettle-dev" exposes them lazily
+# for tests and executables. Files will be loaded on first constant access.
 module Kettle
+  autoload :EmojiRegex, "kettle/emoji_regex"
   module Dev
+    autoload :ChangelogCLI, "kettle/dev/changelog_cli"
+    autoload :CIHelpers, "kettle/dev/ci_helpers"
+    autoload :CIMonitor, "kettle/dev/ci_monitor"
+    autoload :CommitMsg, "kettle/dev/commit_msg"
+    autoload :ExitAdapter, "kettle/dev/exit_adapter"
+    autoload :GemSpecReader, "kettle/dev/gem_spec_reader"
+    autoload :GitAdapter, "kettle/dev/git_adapter"
+    autoload :GitCommitFooter, "kettle/dev/git_commit_footer"
+    autoload :InputAdapter, "kettle/dev/input_adapter"
+    autoload :ReadmeBackers, "kettle/dev/readme_backers"
+    autoload :ReleaseCLI, "kettle/dev/release_cli"
+    autoload :TemplateHelpers, "kettle/dev/template_helpers"
+    autoload :Version, "kettle/dev/version"
+    autoload :Versioning, "kettle/dev/versioning"
+
+    # Nested tasks namespace with autoloaded task modules
+    module Tasks
+      autoload :CITask, "kettle/dev/tasks/ci_task"
+      autoload :InstallTask, "kettle/dev/tasks/install_task"
+      autoload :TemplateTask, "kettle/dev/tasks/template_task"
+    end
+
     # Base error type for kettle-dev.
     class Error < StandardError; end
 
     # Whether debug logging is enabled for kettle-dev internals.
     # @return [Boolean]
     DEBUGGING = ENV.fetch("DEBUG", "false").casecmp("true").zero?
+    # Backwards-compat for kettle-dev specific debug variable
+    DEBUGGING ||= ENV.fetch("KETTLE_DEV_DEBUG", "false").casecmp("true").zero?
     # Whether we are running on CI.
     # @return [Boolean]
     IS_CI = ENV.fetch("CI", "false").casecmp("true") == 0
     # Whether to benchmark requires with require_bench.
     # @return [Boolean]
     REQUIRE_BENCH = ENV.fetch("REQUIRE_BENCH", "false").casecmp("true").zero?
-    # Whether to load rake tasks at the bottom of this file.
-    # Normally they would be loaded in the project's Rakefile,
-    #   but if we do that in this project then we can't get accurate code coverage.
-    # @return [Boolean]
+    # The current program name (e.g., "rake", "rspec").
+    # Used to decide whether to auto-load rake tasks at the bottom of this file.
+    # Normally tasks are loaded in the host project's Rakefile, but when running
+    # under this gem's own test suite we need precise coverage; so we only
+    # auto-install tasks when invoked via the rake executable.
+    # @return [String]
     RUNNING_AS = File.basename($PROGRAM_NAME)
 
     @defaults = []
 
     class << self
+      # Emit a debug warning for rescued errors when DEBUG=true.
+      # @param error [Exception]
+      # @param context [String, Symbol, nil] optional label, often __method__
+      # @return [void]
+      def debug_error(error, context = nil)
+        return unless DEBUGGING
+        ctx = context ? context.to_s : "rescue"
+        Kernel.warn("[#{ctx}] #{error.class}: #{error.message}")
+      rescue Exception
+        # never raise from debug logging
+      end
+
       # Install Rake tasks useful for development and tests.
       #
       # Adds RuboCop-LTS tasks, coverage tasks, and loads the
@@ -107,37 +147,4 @@ module Kettle
   end
 end
 
-# Autoload public CLI/APIs so requiring "kettle-dev" exposes them lazily
-# for tests and executables. Files will be loaded on first constant access.
-module Kettle
-  autoload :EmojiRegex, "kettle/emoji_regex"
-  module Dev
-    autoload :ChangelogCLI, "kettle/dev/changelog_cli"
-    autoload :CIHelpers, "kettle/dev/ci_helpers"
-    autoload :CIMonitor, "kettle/dev/ci_monitor"
-    autoload :CommitMsg, "kettle/dev/commit_msg"
-    autoload :ExitAdapter, "kettle/dev/exit_adapter"
-    autoload :GemSpecReader, "kettle/dev/gem_spec_reader"
-    autoload :GitAdapter, "kettle/dev/git_adapter"
-    autoload :GitCommitFooter, "kettle/dev/git_commit_footer"
-    autoload :InputAdapter, "kettle/dev/input_adapter"
-    autoload :ReadmeBackers, "kettle/dev/readme_backers"
-    autoload :ReleaseCLI, "kettle/dev/release_cli"
-    autoload :TemplateHelpers, "kettle/dev/template_helpers"
-    autoload :Version, "kettle/dev/version"
-    autoload :Versioning, "kettle/dev/versioning"
-
-    # Nested tasks namespace with autoloaded task modules
-    module Tasks
-      autoload :CITask, "kettle/dev/tasks/ci_task"
-      autoload :InstallTask, "kettle/dev/tasks/install_task"
-      autoload :TemplateTask, "kettle/dev/tasks/template_task"
-    end
-  end
-end
-
-Kettle::Dev::Version.class_eval do
-  extend VersionGem::Basic
-end
-
 Kettle::Dev.install_tasks if Kettle::Dev::RUNNING_AS == "rake"

data/sig/kettle/dev/git_adapter.rbs

@@ -2,15 +2,16 @@ module Kettle
   module Dev
     class GitAdapter
       def initialize: () -> void
-      def push: (String?, String, force: bool) -> bool
+      def capture: (Array[String] args) -> [String, bool]
+      def push: (String? remote, String branch, force: bool) -> bool
       def current_branch: () -> String?
       def remotes: () -> Array[String]
       def remotes_with_urls: () -> Hash[String, String]
-      def remote_url: (String) -> String?
-      def checkout: (String) -> bool
-      def pull: (String, String) -> bool
-      def fetch: (String, String?) -> bool
-      def capture: (Array[String]) -> [String, bool]
+      def remote_url: (String name) -> String?
+      def checkout: (String branch) -> bool
+      def pull: (String remote, String branch) -> bool
+      def fetch: (String remote, String? ref) -> bool
+      def clean?: () -> bool
     end
   end
 end

data/sig/kettle/dev/tasks.rbs

@@ -0,0 +1,7 @@
+module Kettle
+  module Dev
+    module Tasks
+      # Namespace module for task-related classes and Rake task loaders.
+    end
+  end
+end

data/sig/kettle/dev.rbs

@@ -10,6 +10,7 @@ module Kettle
     DEBUGGING: bool
     IS_CI: bool
     REQUIRE_BENCH: bool
+    RUNNING_AS: String
 
     # Singleton methods
     def self.install_tasks: () -> void