kettle-dev 1.2.4 → 2.0.1

data/lib/kettle/dev/release_cli.rb

@@ -21,7 +21,7 @@ module Kettle
           # For Bundler-invoked build/release, explicitly prefix SKIP_GEM_SIGNING so
           # the signing step is skipped even when Bundler scrubs ENV.
           # Always do this on CI to avoid interactive prompts; locally only when explicitly requested.
-          if ENV["SKIP_GEM_SIGNING"] && cmd =~ /\Abundle(\s+exec)?\s+rake\s+(build|release)\b/
+          if ENV["SKIP_GEM_SIGNING"] && /\Abundle(\s+exec)?\s+rake\s+(build|release)\b/.match?(cmd)
             cmd = "SKIP_GEM_SIGNING=true #{cmd}"
           end
           puts "$ #{cmd}"
@@ -31,7 +31,7 @@ module Kettle
           # Some commands are interactive (e.g., `bundle exec rake release` prompting for RubyGems MFA).
           # Using capture3 detaches STDIN, preventing prompts from working. For such commands, use system
           # so they inherit the current TTY and can read the user's input.
-          interactive = cmd =~ /\Abundle(\s+exec)?\s+rake\s+release\b/ || cmd =~ /\Agem\s+push\b/
+          interactive = /\Abundle(\s+exec)?\s+rake\s+release\b/.match?(cmd) || /\Agem\s+push\b/.match?(cmd)
           if interactive
             ok = system(env_hash, cmd)
             unless ok
@@ -97,9 +97,9 @@ module Kettle
             gem_name = detect_gem_name
             latest_overall, latest_for_series = latest_released_versions(gem_name, version)
           rescue StandardError => e
-            warn("[kettle-release] RubyGems check failed: #{e.class}: #{e.message}")
-            warn(e.backtrace.first(3).map { |l| "  " + l }.join("\n")) if ENV["DEBUG"]
-            warn("Proceeding without RubyGems latest version info.")
+            warn("[kettle-release] gem.coop release check failed: #{e.class}: #{e.message}")
+            warn(e.backtrace.first(3).map { |l| "  " + l }.join("\n")) if ENV["KETTLE_DEV_DEBUG"]
+            warn("Proceeding without gem.coop latest version info.")
           end
 
           if latest_overall
@@ -121,7 +121,7 @@ module Kettle
               latest_for_series = nil unless lfs_series == cur_series
             end
             # Determine the sanity-check target correctly for the current series.
-            # If RubyGems has a newer overall series than our current series, only compare
+            # If gem.coop has a newer overall series than our current series, only compare
             # against the latest published in our current series. If that cannot be determined
             # (e.g., offline), skip the sanity check rather than treating the overall as target.
             target = if (cur_series <=> overall_series) == -1
@@ -130,10 +130,10 @@ module Kettle
               latest_overall
             end
             # IMPORTANT: Never treat a higher different-series "latest_overall" as a downgrade target.
-            # If our current series is behind overall and RubyGems does not report a latest_for_series,
+            # If our current series is behind overall and gem.coop does not report a latest_for_series,
             # then we cannot determine the correct target for this series and should skip the check.
             if (cur_series <=> overall_series) == -1 && target.nil?
-              puts "Could not determine latest released version from RubyGems (offline?). Proceeding without sanity check."
+              puts "Could not determine latest released version from gem.coop (offline?). Proceeding without sanity check."
             elsif target
               bump = Kettle::Dev::Versioning.classify_bump(target, version)
               case bump
@@ -150,10 +150,10 @@ module Kettle
                 puts "Proposed bump type: #{label} (from #{target} -> #{version})"
               end
             else
-              puts "Could not determine latest released version from RubyGems (offline?). Proceeding without sanity check."
+              puts "Could not determine latest released version from gem.coop (offline?). Proceeding without sanity check."
             end
           else
-            puts "Could not determine latest released version from RubyGems (offline?). Proceeding without sanity check."
+            puts "Could not determine latest released version from gem.coop (offline?). Proceeding without sanity check."
           end
 
           puts "Have you updated lib/**/version.rb and CHANGELOG.md for v#{version}? [y/N]"
@@ -184,15 +184,18 @@ module Kettle
         # 4. bin/rake
         run_cmd!("bin/rake") if @start_step <= 4
 
-        # 5. appraisal:update (optional)
+        # 5. appraisal:update (optional) + canonical docs build
         if @start_step <= 5
           appraisals_path = File.join(@root, "Appraisals")
           if File.file?(appraisals_path)
-            puts "Appraisals detected at #{appraisals_path}. Running: bin/rake appraisal:update"
+            puts "Appraisals detected at #{Kettle::Dev.display_path(appraisals_path)}. Running: bin/rake appraisal:update"
             run_cmd!("bin/rake appraisal:update")
           else
             puts "No Appraisals file found; skipping appraisal:update"
           end
+
+          puts "Generating docs site via canonical task: bin/rake yard"
+          run_cmd!("bin/rake yard")
         end
 
         # 6. git user + commit release prep
@@ -317,7 +320,7 @@ module Kettle
         return unless section
 
         # Example match: "- COVERAGE: 97.70% -- 2125/2175 lines in 20 files"
-        m = section.lines.find { |l| l =~ /-\s*COVERAGE:\s*.+--\s*\d+\/(\d+)\s+lines/i }
+        m = section.lines.find { |l| /-\s*COVERAGE:\s*.+--\s*\d+\/(\d+)\s+lines/i.match?(l) }
         return unless m
 
         denom = m.match(/-\s*COVERAGE:\s*.+--\s*\d+\/(\d+)\s+lines/i)[1].to_i
@@ -408,7 +411,7 @@ module Kettle
         content = File.read(path)
         # Only consider lines that look like copyright notices to reduce false positives
         content.each_line do |line|
-          next unless line =~ /copyright/i
+          next unless /copyright/i.match?(line)
 
           # Expand ranges first (supports hyphen-minus and en dash)
           line.scan(/\b(19\d{2}|20\d{2})\s*[\-–]\s*(19\d{2}|20\d{2})\b/).each do |a, b|
@@ -459,7 +462,7 @@ module Kettle
         changed = false
         canonical_all = collapse_years(years_set)
         new_lines = content.each_line.map do |line|
-          unless line =~ /copyright/i
+          unless /copyright/i.match?(line)
             next line
           end
 
@@ -483,7 +486,7 @@ module Kettle
         content = File.read(path)
         changed = false
         new_lines = content.each_line.map do |line|
-          unless line =~ /copyright/i
+          unless /copyright/i.match?(line)
             next line
           end
 
@@ -556,7 +559,7 @@ module Kettle
         when "ask"
           print("Run local CI with 'act' before pushing? [Y/n] ")
           ans = Kettle::Dev::InputAdapter.gets&.strip
-          ans.nil? || ans.empty? || ans =~ /\Ay(es)?\z/i
+          ans.nil? || ans.empty? || /\Ay(es)?\z/i.match?(ans)
         else
           false
         end
@@ -579,7 +582,7 @@ module Kettle
 
         chosen = (ENV["K_RELEASE_LOCAL_CI_WORKFLOW"] || "").strip
         if !chosen.empty?
-          chosen = "#{chosen}.yml" unless chosen =~ /\.ya?ml\z/
+          chosen = "#{chosen}.yml" unless /\.ya?ml\z/.match?(chosen)
         else
           chosen = if candidates.include?("locked_deps.yml")
             "locked_deps.yml"
@@ -597,7 +600,7 @@ module Kettle
 
         file_path = File.join(workflows_dir, chosen)
         unless File.file?(file_path)
-          puts "Skipping local CI: selected workflow not found: #{file_path}"
+          puts "Skipping local CI: selected workflow not found: #{Kettle::Dev.display_path(file_path)}"
           return
         end
 
@@ -625,18 +628,18 @@ module Kettle
         path = gemspecs.min
         content = File.read(path)
         m = content.match(/spec\.name\s*=\s*(["'])([^"']+)\1/)
-        abort("Could not determine gem name from #{path}.") unless m
+        abort("Could not determine gem name from #{Kettle::Dev.display_path(path)}.") unless m
         m[2]
       end
 
       def latest_released_versions(gem_name, current_version)
-        uri = URI("https://rubygems.org/api/v1/versions/#{gem_name}.json")
+        uri = URI("https://gem.coop/api/v1/versions/#{gem_name}.json")
         res = Net::HTTP.get_response(uri)
         return [nil, nil] unless res.is_a?(Net::HTTPSuccess)
 
         data = JSON.parse(res.body)
         versions = data.map { |h| h["number"] }.compact
-        versions.reject! { |v| v.to_s.include?("-pre") || v.to_s.include?(".pre") || v.to_s =~ /[a-zA-Z]/ }
+        versions.reject! { |v| v.to_s.include?("-pre") || v.to_s.include?(".pre") || /[a-zA-Z]/.match?(v.to_s) }
         gversions = versions.map { |s| Gem::Version.new(s) }.sort
         latest_overall = gversions.last&.to_s
 
@@ -924,11 +927,11 @@ module Kettle
         unless File.exist?(cert_path)
           abort(<<~MSG)
             Gem signing appears enabled but no public cert found at:
-              #{cert_path}
+              #{Kettle::Dev.display_path(cert_path)}
             Add your public key to certs/<USER>.pem (or set GEM_CERT_USER), or set SKIP_GEM_SIGNING to build unsigned.
           MSG
         end
-        puts "Found signing cert: #{cert_path}"
+        puts "Found signing cert: #{Kettle::Dev.display_path(cert_path)}"
         puts "When prompted during build/release, enter the PEM password for ~/.ssh/gem-private_key.pem"
       end
 

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

@@ -265,11 +265,11 @@ module Kettle
           selected = nil
           # Create input thread always so specs that assert its cleanup/exception behavior can exercise it,
           # but guard against non-interactive stdin by rescuing 'bad tty' and similar errors immediately.
-          input_thread = Thread.new do
+          input_thread = Thread.new do # rubocop:disable ThreadSafety/NewThread
             begin
               selected = Kettle::Dev::InputAdapter.gets&.strip
-            rescue Exception => error
-              # Catch all exceptions in background thread, including SystemExit
+            rescue StandardError, SystemExit, Interrupt => error
+              # Catch exceptions in background thread, including SystemExit
               # NOTE: look into refactoring to minimize potential SystemExit.
               puts "Error in background thread: #{error.class}: #{error.message}" if Kettle::Dev::DEBUGGING
               selected = :input_error
@@ -281,7 +281,7 @@ module Kettle
           start_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
 
           options.each do |code, file|
-            workers << Thread.new(code, file, owner, repo, branch, token, start_at) do |c, f, ow, rp, br, tk, st_at|
+            workers << Thread.new(code, file, owner, repo, branch, token, start_at) do |c, f, ow, rp, br, tk, st_at| # rubocop:disable ThreadSafety/NewThread
               begin
                 now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
                 delay = 0.12 - (now - st_at)

data/lib/kettle/dev/version.rb

@@ -2,94 +2,9 @@
 
 module Kettle
   module Dev
-    # Version namespace for kettle-dev.
     module Version
-      # The gem version.
-      # @return [String]
-      VERSION = "1.2.4"
-
-      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
+      VERSION = "2.0.1"
     end
+    VERSION = Version::VERSION # Traditional Constant Location
   end
 end

data/lib/kettle/dev.rb

@@ -1,6 +1,13 @@
 # frozen_string_literal: true
 
+require "version_gem"
+require_relative "dev/version"
+
+Kettle::Dev::Version.class_eval do
+  extend VersionGem::Basic
+end
 # External gems
+
 # It's not reasonable to test this ENV variable
 # :nocov:
 require "require_bench" if ENV.fetch("REQUIRE_BENCH", "false").casecmp("true").zero?
@@ -21,35 +28,25 @@ module Kettle
     autoload :GitAdapter, "kettle/dev/git_adapter"
     autoload :GitCommitFooter, "kettle/dev/git_commit_footer"
     autoload :InputAdapter, "kettle/dev/input_adapter"
-    autoload :PrismUtils, "kettle/dev/prism_utils"
-    autoload :PrismGemspec, "kettle/dev/prism_gemspec"
-    autoload :PrismGemfile, "kettle/dev/prism_gemfile"
-    autoload :PrismAppraisals, "kettle/dev/prism_appraisals"
     autoload :ReadmeBackers, "kettle/dev/readme_backers"
     autoload :OpenCollectiveConfig, "kettle/dev/open_collective_config"
-    autoload :SourceMerger, "kettle/dev/source_merger"
     autoload :ReleaseCLI, "kettle/dev/release_cli"
     autoload :PreReleaseCLI, "kettle/dev/pre_release_cli"
-    autoload :SetupCLI, "kettle/dev/setup_cli"
-    autoload :TemplateHelpers, "kettle/dev/template_helpers"
-    autoload :ModularGemfiles, "kettle/dev/modular_gemfiles"
     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.
-    # KETTLE_DEV_DEBUG overrides DEBUG.
+    # Controlled by KETTLE_DEV_DEBUG=true.
     # @return [Boolean]
-    DEBUGGING = ENV.fetch("KETTLE_DEV_DEBUG", ENV.fetch("DEBUG", "false")).casecmp("true").zero?
+    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
@@ -76,25 +73,42 @@ module Kettle
     # @return [String]
     GEM_ROOT = File.expand_path("../..", __dir__)
 
-    @defaults = []
+    @defaults = [].freeze
 
     class << self
+      VAR_HOME_PREFIX = %r{\A/var/home(?=/|\z)}
+      VAR_HOME_TEXT = %r{/var/home(?=/|\z)}
+
+      def display_path(path)
+        return path if path.nil?
+
+        path.to_s.sub(VAR_HOME_PREFIX, "/home")
+      end
+
+      def display_text(text)
+        return text if text.nil?
+
+        text.to_s.gsub(VAR_HOME_TEXT, "/home")
+      end
+
       # Emit a debug warning for rescued errors when kettle-dev debugging is enabled.
-      # Controlled by KETTLE_DEV_DEBUG=true (or DEBUG=true as fallback).
+      # Controlled by KETTLE_DEV_DEBUG=true.
       # @param error [Exception]
       # @param context [String, Symbol, nil] optional label, often __method__
+      # @param backtrace [Boolean] whether to emit the rescued error backtrace
       # @return [void]
-      def debug_error(error, context = nil)
+      def debug_error(error, context = nil, backtrace: true)
         return unless DEBUGGING
 
         ctx = context ? context.to_s : "KETTLE-DEV-RESCUE"
         Kernel.warn("[#{ctx}] #{error.class}: #{error.message}")
+        Kernel.warn(Array(error.backtrace).first(5).join("\n")) if backtrace && error.respond_to?(:backtrace) && error.backtrace
       rescue StandardError
         # never raise from debug logging
       end
 
       # Emit a debug log line when kettle-dev debugging is enabled.
-      # Controlled by KETTLE_DEV_DEBUG=true (or DEBUG=true as fallback).
+      # Controlled by KETTLE_DEV_DEBUG=true.
       # @param msg [String]
       # @return [void]
       def debug_log(msg, context = nil)
@@ -128,7 +142,7 @@ module Kettle
       def register_default(task_name)
         task_name = task_name.to_s
         unless defaults.include?(task_name)
-          defaults << task_name
+          @defaults = (defaults + [task_name]).freeze # rubocop:disable ThreadSafety/ClassInstanceVariable
           if defined?(Rake) && Rake::Task.task_defined?(:default)
             begin
               Rake::Task[:default].enhance([task_name])

data/sig/kettle/dev/source_merger.rbs

@@ -2,15 +2,24 @@
 
 module Kettle
   module Dev
-    # Prism-based AST merging for templated Ruby files
+    # Prism-based AST merging for templated Ruby files.
+    # Handles strategy dispatch (skip/replace/append/merge).
+    #
+    # Uses prism-merge for AST-aware merging with support for:
+    # - Freeze blocks (kettle-dev:freeze / kettle-dev:unfreeze)
+    # - Comment preservation
+    # - Signature-based node matching
     module SourceMerger
-      FREEZE_START: Regexp
-      FREEZE_END: Regexp
-      FREEZE_BLOCK: Regexp
-      FREEZE_REMINDER: String
       BUG_URL: String
 
       # Apply a templating strategy to merge source and destination Ruby files
+      #
+      # @param strategy [Symbol] Merge strategy - :skip, :replace, :append, or :merge
+      # @param src [String] Template source content
+      # @param dest [String] Destination file content
+      # @param path [String] File path (for error messages)
+      # @return [String] Merged content with comments preserved
+      # @raise [Kettle::Dev::Error] If strategy is unknown or merge fails
       def self.apply: (
         strategy: Symbol,
         src: String,
@@ -18,69 +27,44 @@ module Kettle
         path: String
       ) -> String
 
-      # Ensure freeze reminder comment is present at the top of content
-      def self.ensure_reminder: (String content) -> String
-
-      # Normalize source code while preserving formatting
-      def self.normalize_source: (String source) -> String
-
-      # Check if freeze reminder is present in content
-      def self.reminder_present?: (String content) -> bool
-
-      # Find index where freeze reminder should be inserted
-      def self.reminder_insertion_index: (String content) -> Integer
-
-      # Check if line is a shebang
-      def self.shebang?: (String line) -> bool
-
-      # Check if line is a frozen_string_literal comment
-      def self.frozen_comment?: (String line) -> bool
-
-      # Merge kettle-dev:freeze blocks from destination into source content
-      def self.merge_freeze_blocks: (String src_content, String dest_content) -> String
-
-      # Extract freeze blocks from text
-      def self.freeze_blocks: (String? text) -> Array[Hash[Symbol, untyped]]
-
       # Normalize strategy symbol
+      #
+      # @param strategy [Symbol, nil] Strategy to normalize
+      # @return [Symbol] Normalized strategy (:skip if nil)
       def self.normalize_strategy: (Symbol? strategy) -> Symbol
 
       # Warn about bugs and print error information
+      #
+      # @param path [String] File path that caused the error
+      # @param error [StandardError] The error that occurred
+      # @return [void]
       def self.warn_bug: (String path, StandardError error) -> void
 
       # Ensure text ends with newline
+      #
+      # @param text [String, nil] Text to process
+      # @return [String] Text with trailing newline
       def self.ensure_trailing_newline: (String? text) -> String
 
-      # Apply append strategy
+      # Apply append strategy using prism-merge
+      #
+      # @param src_content [String] Template source content
+      # @param dest_content [String] Destination content
+      # @return [String] Merged content with destination preference
       def self.apply_append: (String src_content, String dest_content) -> String
 
-      # Apply merge strategy
+      # Apply merge strategy using prism-merge
+      #
+      # @param src_content [String] Template source content
+      # @param dest_content [String] Destination content
+      # @return [String] Merged content with template preference
       def self.apply_merge: (String src_content, String dest_content) -> String
 
-      # Merge node information
-      def self.merge_node_info: (Array[untyped] signature, Hash[Symbol, untyped] dest_node_info, Hash[Symbol, untyped] src_node_info) -> Hash[Symbol, untyped]
-
-      # Merge block node information
-      def self.merge_block_node_info: (Hash[Symbol, untyped] src_node_info) -> Hash[Symbol, untyped]
-
-      # Perform Prism-based merge with block
-      def self.prism_merge: (String src_content, String dest_content) { (Array[Hash[Symbol, untyped]], Array[Hash[Symbol, untyped]], Prism::ParseResult, Prism::ParseResult) -> Array[Hash[Symbol, untyped]] } -> String
-
-      # Extract nodes with comments from parse result
-      def self.extract_nodes_with_comments: (Prism::ParseResult parse_result) -> Array[Hash[Symbol, untyped]]
-
-      # Build source from node information array
-      def self.build_source_from_nodes: (Array[Hash[Symbol, untyped]] node_infos) -> String
-
-      # Generate signature for node
-      def self.node_signature: (Prism::Node? node) -> Array[untyped]
-
-      # Restore custom leading comments from destination
-      def self.restore_custom_leading_comments: (String dest_content, String merged_content) -> String
-
-      # Extract leading comment block from content
-      def self.leading_comment_block: (String content) -> String
+      # Create a signature generator for prism-merge
+      # Handles various Ruby node types for proper matching during merge operations
+      #
+      # @return [Proc] Signature generator lambda
+      def self.create_signature_generator: () -> ^(Prism::Node) -> (Array[untyped] | Prism::Node)
     end
   end
-end
-
+end

data/sig/kettle/dev/version.rbs

@@ -0,0 +1,8 @@
+module Kettle
+  module Dev
+    module Version
+      VERSION: String
+    end
+    VERSION: String
+  end
+end