kettle-dev 1.2.3 → 2.0.0

data/exe/kettle-dev-setup

@@ -3,66 +3,15 @@
 
 # vim: set syntax=ruby
 
-# kettle-dev-setup: initialize a target gem repo to use kettle-dev tooling.
-# This script is installed into PATH when the kettle-dev gem is installed.
-# It is designed to be run from inside the target gem's repository working
-# directory. It will not assume kettle-dev is already a dependency.
-
-require "fileutils"
-require "shellwords"
-require "open3"
-require "optparse"
-require "rubygems"
-
-# Ensure output is flushed promptly even if we exit early
-$stdout.sync = true
-$stderr.sync = true
-
-script_basename = File.basename(__FILE__)
-File.basename($PROGRAM_NAME)
-
-begin
-  require "kettle/dev"
-  puts "== #{script_basename} v#{Kettle::Dev::Version::VERSION} begin =="
-rescue StandardError => e
-  # Requiring kettle/dev should generally work since this script ships with the gem.
-  # But if autoloads try to pull optional deps, we should still proceed as most
-  # of this script does not rely on those parts.
-  warn("[kettle-dev-setup] Warning: could not fully load kettle/dev (#{e.class}: #{e.message}). Proceeding with limited features.")
-end
-
-# Always execute when this file is loaded (e.g., via a Bundler binstub).
-# Do not guard with __FILE__ == $PROGRAM_NAME because binstubs use Kernel.load.
-if ARGV.include?("-h") || ARGV.include?("--help")
-  puts <<~USAGE
-    Usage: kettle-dev-setup [options]
-
-    Bootstraps a host gem repository to use kettle-dev tooling.
-
-    Options (passed through to rake kettle:dev:install):
-      --allowed=VAL
-      --force
-      --hook_templates=VAL
-      --only=VAL
-      --include=VAL
-
-    Environment:
-      DEBUG=true                    # print backtraces on errors
-  USAGE
-  exit 0
-end
-
-begin
-  Kettle::Dev::SetupCLI.new(ARGV).run!
-rescue LoadError => e
-  warn("#{script_basename}: could not load dependency: #{e.class}: #{e.message}")
-  warn(e.backtrace.join("\n")) if ENV["DEBUG"]
-  exit(1)
-rescue SystemExit => e
-  warn("#{script_basename}: exited (status=#{e.status}, msg=#{e.message})") if e.status != 0
-  raise
-rescue StandardError => e
-  warn("#{script_basename}: unexpected error: #{e.class}: #{e.message}")
-  warn(e.backtrace.join("\n")) if ENV["DEBUG"]
-  exit(1)
-end
+# kettle-dev-setup has been replaced by kettle-jem-setup.
+# All setup and templating functionality has moved to the kettle-jem gem.
+
+$stderr.puts <<~MSG
+  kettle-dev-setup has been removed.
+  Setup and templating functionality has moved to the kettle-jem gem.
+
+  Please install kettle-jem and use kettle-jem-setup instead:
+    gem install kettle-jem
+    kettle-jem-setup
+MSG
+exit 1

data/exe/kettle-gh-release

@@ -0,0 +1,82 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# vim: set syntax=ruby
+
+# kettle-gh-release: Create a GitHub release for a gem version
+# - Extracted from kettle-release step 18
+# - Useful when the main release succeeded but GitHub release creation failed
+# - Requires GITHUB_TOKEN with repo:public_repo (classic) or contents:write scope
+
+# Immediate, unbuffered output
+$stdout.sync = true
+$stderr.sync = true
+
+# Do not rely on Bundler; allow running in repos that do not depend on kettle-dev
+# Ensure RubyGems is available for 'require' lookups
+begin
+  require "rubygems"
+rescue LoadError
+  # Older Rubies always have rubygems; continue anyway
+end
+
+script_basename = File.basename(__FILE__)
+
+begin
+  require "kettle/dev"
+  puts "== #{script_basename} v#{Kettle::Dev::Version::VERSION} =="
+rescue LoadError => e
+  warn("#{script_basename}: could not load dependency: #{e.class}: #{e.message}")
+  warn("Hint: Ensure the host project has kettle-dev as a dependency and run bundle install.")
+  exit(1)
+end
+
+# Always execute when this file is loaded (e.g., via a Bundler binstub).
+# Do not guard with __FILE__ == $PROGRAM_NAME because binstubs use Kernel.load.
+if ARGV.include?("-h") || ARGV.include?("--help")
+  puts <<~USAGE
+    Usage: #{script_basename} [version=<VERSION>]
+
+    Creates a GitHub release for a gem version.
+
+    This is step 18 of the kettle-release flow, extracted as a standalone script.
+    Useful when the main release to RubyGems succeeded but GitHub release creation
+    failed (e.g., due to token issues or network problems).
+
+    Arguments:
+      version=<VERSION>           # Explicit version (e.g., version=1.2.3)
+                                  # If omitted, auto-detects from lib/**/version.rb
+
+    Environment:
+      GITHUB_TOKEN / GH_TOKEN     # Required; needs repo:public_repo (classic) or contents:write scope
+      DEBUG=true                  # Print backtraces on errors
+
+    Examples:
+      #{script_basename}                    # auto-detect version, create release
+      #{script_basename} version=2.0.0      # create release for specific version
+      GITHUB_TOKEN=ghp_xxx #{script_basename}  # explicit token
+  USAGE
+  exit 0
+end
+
+# Parse version=<v> from ARGV
+version_arg = ARGV.find { |a| a.start_with?("version=") }
+explicit_version = version_arg ? version_arg.split("=", 2)[1].strip : nil
+
+begin
+  cli = Kettle::Dev::ReleaseCLI.new(start_step: 18)
+  version = explicit_version || cli.send(:detect_version)
+  cli.send(:maybe_create_github_release!, version)
+rescue LoadError => e
+  warn("#{script_basename}: could not load dependency: #{e.class}: #{e.message}")
+  warn(Array(e.backtrace).join("\n")) if ENV["DEBUG"]
+  exit(1)
+rescue SystemExit => e
+  # Preserve exit status, but ensure at least a newline so shells don't show an empty line only.
+  warn("#{script_basename}: exited (status=#{e.status}, msg=#{e.message})") if e.status != 0
+  raise
+rescue StandardError => e
+  warn("#{script_basename}: unexpected error: #{e.class}: #{e.message}")
+  warn(Array(e.backtrace).join("\n"))
+  exit(1)
+end

data/lib/kettle/dev/gem_spec_reader.rb

@@ -99,13 +99,13 @@ module Kettle
 
           # Funding org (Open Collective handle) detection.
           # Precedence:
-          #   1) TemplateHelpers.opencollective_disabled? - when true, funding_org is nil
+          #   1) OpenCollectiveConfig.disabled? - when true, funding_org is nil
           #   2) ENV["FUNDING_ORG"] when set and non-empty (unless already disabled above)
           #   3) OpenCollectiveConfig.handle(required: false)
           # Be lenient: allow nil when not discoverable, with a concise warning.
           begin
             # Check if Open Collective is explicitly disabled via environment variables
-            if TemplateHelpers.opencollective_disabled?
+            if OpenCollectiveConfig.disabled?
               funding_org = nil
             else
               env_funding = ENV["FUNDING_ORG"]

data/lib/kettle/dev/open_collective_config.rb

@@ -10,6 +10,18 @@ module Kettle
     module OpenCollectiveConfig
       module_function
 
+      # Check if Open Collective is disabled via environment variable.
+      # Returns true when OPENCOLLECTIVE_HANDLE or FUNDING_ORG is explicitly set to a falsey value.
+      # @return [Boolean]
+      def disabled?
+        oc_handle = ENV["OPENCOLLECTIVE_HANDLE"]
+        funding_org = ENV["FUNDING_ORG"]
+
+        [oc_handle, funding_org].any? do |val|
+          val && val.to_s.strip.match(Kettle::Dev::ENV_FALSE_RE)
+        end
+      end
+
       # Absolute path to a .opencollective.yml
       # @param root [String, nil] optional project root to resolve against; when nil, uses this repo root
       # @return [String]

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

@@ -4,6 +4,21 @@
 begin
   require "yard"
 
+  # Load yard-fence rake task if available (provides yard:fence:prepare)
+  # NOTE: yard-fence >= 0.9 auto-registers its rake task when Rake is available,
+  # so this explicit require may be redundant. We keep it for backward compatibility
+  # with older yard-fence versions that don't auto-register.
+  # The yard:fence:prepare task handles:
+  # - Cleaning docs/ directory (if YARD_FENCE_CLEAN_DOCS=true)
+  # - Preparing tmp/yard-fence/ with sanitized markdown files
+  begin
+    require "yard/fence/rake_task"
+    # Only create if not already defined (yard-fence may have auto-registered)
+    Yard::Fence::RakeTask.new unless Rake::Task.task_defined?("yard:fence:prepare")
+  rescue LoadError
+    # yard-fence not available or doesn't have rake_task - that's fine
+  end
+
   YARD::Rake::YardocTask.new(:yard) do |t|
     t.files = [
       # Source Splats (alphabetical)

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

@@ -6,7 +6,7 @@ module Kettle
     module Version
       # The gem version.
       # @return [String]
-      VERSION = "1.2.3"
+      VERSION = "2.0.0"
 
       module_function
 

data/lib/kettle/dev.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 # 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,26 +22,16 @@ 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.
@@ -76,7 +67,7 @@ module Kettle
     # @return [String]
     GEM_ROOT = File.expand_path("../..", __dir__)
 
-    @defaults = []
+    @defaults = [].freeze
 
     class << self
       # Emit a debug warning for rescued errors when kettle-dev debugging is enabled.
@@ -89,6 +80,7 @@ module Kettle
 
         ctx = context ? context.to_s : "KETTLE-DEV-RESCUE"
         Kernel.warn("[#{ctx}] #{error.class}: #{error.message}")
+        Kernel.warn(error.backtrace.first(5).join("\n")) if error.respond_to?(:backtrace) && error.backtrace
       rescue StandardError
         # never raise from debug logging
       end
@@ -128,7 +120,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