kettle-dev 1.1.4 → 1.1.5

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

@@ -55,12 +55,7 @@ module Kettle
           dynamic_files.each { |f| display_code_for[f] = "" }
 
           status_emoji = proc do |status, conclusion|
-            case status
-            when "queued" then "⏳️"
-            when "in_progress" then "👟"
-            when "completed" then ((conclusion == "success") ? "✅" : "🍅")
-            else "⏳️"
-            end
+            Kettle::Dev::CIMonitor.status_emoji(status, conclusion)
           end
 
           fetch_and_print_status = proc do |workflow_file|
@@ -98,6 +93,52 @@ module Kettle
             end
           end
 
+          # Print GitLab pipeline status (if configured) for the current branch.
+          print_gitlab_status = proc do
+            begin
+              branch = Kettle::Dev::CIHelpers.current_branch
+              # Detect any GitLab remote (not just origin), mirroring CIMonitor behavior
+              gl_remotes = Kettle::Dev::CIMonitor.gitlab_remote_candidates
+              if gl_remotes.nil? || gl_remotes.empty? || branch.nil?
+                puts "Latest GL (#{branch || "n/a"}) pipeline: n/a"
+                next
+              end
+
+              # Parse owner/repo from the first GitLab remote URL
+              gl_url = Kettle::Dev::CIMonitor.remote_url(gl_remotes.first)
+              owner = repo = nil
+              if gl_url =~ %r{git@gitlab.com:(.+?)/(.+?)(\.git)?$}
+                owner = Regexp.last_match(1)
+                repo = Regexp.last_match(2).sub(/\.git\z/, "")
+              elsif gl_url =~ %r{https://gitlab.com/(.+?)/(.+?)(\.git)?$}
+                owner = Regexp.last_match(1)
+                repo = Regexp.last_match(2).sub(/\.git\z/, "")
+              end
+
+              unless owner && repo
+                puts "Latest GL (#{branch}) pipeline: n/a"
+                next
+              end
+
+              pipe = Kettle::Dev::CIHelpers.gitlab_latest_pipeline(owner: owner, repo: repo, branch: branch)
+              if pipe
+                st = pipe["status"].to_s
+                status = if st == "success"
+                  "success"
+                else
+                  ((st == "failed") ? "failure" : nil)
+                end
+                emoji = Kettle::Dev::CIMonitor.status_emoji(st, status)
+                details = [st, pipe["failure_reason"]].compact.join("/")
+                puts "Latest GL (#{branch}) pipeline: #{emoji} (#{details})"
+              else
+                puts "Latest GL (#{branch}) pipeline: none"
+              end
+            rescue StandardError => e
+              puts "GL status: error #{e.class}: #{e.message}"
+            end
+          end
+
           run_act_for = proc do |file_path|
             ok = system("act", "-W", file_path)
             task_abort("ci:act failed: 'act' command not found or exited with failure") unless ok
@@ -131,6 +172,7 @@ module Kettle
               task_abort("ci:act aborted")
             end
             fetch_and_print_status.call(file)
+            print_gitlab_status.call
             run_act_for.call(file_path)
             return
           end
@@ -152,13 +194,15 @@ module Kettle
           upstream = begin
             out, status = Open3.capture2("git", "rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{u}")
             status.success? ? out.strip : nil
-          rescue StandardError
+          rescue StandardError => e
+            Kettle::Dev.debug_error(e, __method__)
             nil
           end
           sha = begin
             out, status = Open3.capture2("git", "rev-parse", "--short", "HEAD")
             status.success? ? out.strip : nil
-          rescue StandardError
+          rescue StandardError => e
+            Kettle::Dev.debug_error(e, __method__)
             nil
           end
           if org && branch
@@ -170,6 +214,36 @@ module Kettle
           end
           puts "Upstream: #{upstream || "n/a"}"
           puts "HEAD: #{sha || "n/a"}"
+
+          # Compare remote HEAD SHAs between GitHub and GitLab for current branch and highlight mismatch
+          begin
+            branch_name = branch
+            if branch_name
+              gh_remote = Kettle::Dev::CIMonitor.preferred_github_remote
+              gl_remote = Kettle::Dev::CIMonitor.gitlab_remote_candidates.first
+              gh_sha = nil
+              gl_sha = nil
+              if gh_remote
+                out, status = Open3.capture2("git", "ls-remote", gh_remote.to_s, "refs/heads/#{branch_name}")
+                gh_sha = out.split(/\s+/).first if status.success? && out && !out.empty?
+              end
+              if gl_remote
+                out, status = Open3.capture2("git", "ls-remote", gl_remote.to_s, "refs/heads/#{branch_name}")
+                gl_sha = out.split(/\s+/).first if status.success? && out && !out.empty?
+              end
+              if gh_sha && gl_sha
+                gh_short = gh_sha[0, 7]
+                gl_short = gl_sha[0, 7]
+                if gh_short != gl_short
+                  puts "⚠️ HEAD mismatch on #{branch_name}: GitHub #{gh_short} vs GitLab #{gl_short}"
+                end
+              end
+            end
+          rescue StandardError => e
+            Kettle::Dev.debug_error(e, __method__)
+          end
+
+          print_gitlab_status.call
           puts
           puts "Select a workflow to run with 'act':"
 
@@ -183,14 +257,18 @@ module Kettle
 
           puts "(Fetching latest GHA status for branch #{branch || "n/a"} — you can type your choice and press Enter)"
           prompt = "Enter number or code (or 'q' to quit): "
-          print(prompt)
-          $stdout.flush
+          if tty
+            print(prompt)
+            $stdout.flush
+          end
 
           # We need to sleep a bit here to ensure the terminal is ready for both
           #   input and writing status updates to each workflow's line
           sleep(0.2) unless Kettle::Dev::IS_CI
 
           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
             begin
               selected = Kettle::Dev::InputAdapter.gets&.strip
@@ -198,7 +276,7 @@ module Kettle
               # Catch all 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 = nil
+              selected = :input_error
             end
           end
 
@@ -231,12 +309,7 @@ module Kettle
                       if run
                         st = run["status"]
                         con = run["conclusion"]
-                        emoji = case st
-                        when "queued" then "⏳️"
-                        when "in_progress" then "👟"
-                        when "completed" then ((con == "success") ? "✅" : "🍅")
-                        else "⏳️"
-                        end
+                        emoji = Kettle::Dev::CIMonitor.status_emoji(st, con)
                         details = [st, con].compact.join("/")
                         status_q << [c, f, "#{emoji} (#{details})"]
                         break if st == "completed"
@@ -247,13 +320,15 @@ module Kettle
                     else
                       status_q << [c, f, "fail #{res.code}"]
                     end
-                  rescue Exception
+                  rescue Exception => e # rubocop:disable Lint/RescueException
+                    Kettle::Dev.debug_error(e, __method__)
                     # Catch all exceptions to prevent crashing the process from a worker thread
                     status_q << [c, f, "err"]
                   end
                   sleep(poll_interval)
                 end
-              rescue Exception
+              rescue Exception => e # rubocop:disable Lint/RescueException
+                Kettle::Dev.debug_error(e, __method__)
                 # :nocov:
                 # Catch all exceptions in the worker thread boundary, including SystemExit
                 status_q << [c, f, "err"]
@@ -264,11 +339,22 @@ module Kettle
 
           statuses = Hash.new(placeholder)
 
+          # In non-interactive environments (no TTY) and when not DEBUGGING, auto-quit after a short idle
+          auto_quit_deadline = if !tty && !Kettle::Dev::DEBUGGING
+            Process.clock_gettime(Process::CLOCK_MONOTONIC) + 1.0
+          end
+
           loop do
             if selected
               break
             end
 
+            # Auto-quit if deadline passed without input (non-interactive runs)
+            if auto_quit_deadline && Process.clock_gettime(Process::CLOCK_MONOTONIC) >= auto_quit_deadline
+              selected = "q"
+              break
+            end
+
             begin
               code, file_name, display = status_q.pop(true)
               statuses[code] = display
@@ -291,20 +377,24 @@ module Kettle
                 puts "status #{code}: #{display}"
               end
             rescue ThreadError
+              # ThreadError is raised when the queue is empty,
+              #   and it needs to be silent to maintain the output row alignment
               sleep(0.05)
             end
           end
 
           begin
             workers.each { |t| t.kill if t&.alive? }
-          rescue StandardError
+          rescue StandardError => e
+            Kettle::Dev.debug_error(e, __method__)
           end
           begin
             input_thread.kill if input_thread&.alive?
-          rescue StandardError
+          rescue StandardError => e
+            Kettle::Dev.debug_error(e, __method__)
           end
 
-          input = selected
+          input = (selected == :input_error) ? nil : selected
           task_abort("ci:act aborted: no selection") if input.nil? || input.empty?
 
           chosen_file = nil

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

@@ -61,7 +61,8 @@ module Kettle
                       content = content.gsub(/!\[[^\]]*?\]\s*\[#{label_re}\]/, "")
                       removed_labels << label
                     end
-                  rescue StandardError
+                  rescue StandardError => e
+                    Kettle::Dev.debug_error(e, __method__)
                     # ignore
                   end
                 end
@@ -201,7 +202,8 @@ module Kettle
                         tmp = tmp[cluster.length..-1].to_s
                       end
                       rest_wo_emoji = tmp.sub(/\A\s+/, "")
-                    rescue StandardError
+                    rescue StandardError => e
+                      Kettle::Dev.debug_error(e, __method__)
                       rest_wo_emoji = rest.sub(/\A\s+/, "")
                     end
                     # Build H1 with single spaces only around separators; preserve inner spacing in rest_wo_emoji
@@ -236,7 +238,8 @@ module Kettle
                         end
                         tmp = tmp.sub(/\A\s+/, "")
                         body_wo = tmp
-                      rescue StandardError
+                      rescue StandardError => e
+                        Kettle::Dev.debug_error(e, __method__)
                         body_wo = body.sub(/\A\s+/, "")
                       end
                       pre + q + ("#{chosen_grapheme} " + body_wo) + q
@@ -272,7 +275,8 @@ module Kettle
               end.join
               File.open(readme_path, "w") { |f| f.write(content) }
             end
-          rescue StandardError
+          rescue StandardError => e
+            Kettle::Dev.debug_error(e, __method__)
             # ignore whitespace normalization errors
           end
 
@@ -335,14 +339,14 @@ module Kettle
                 if interpolated || !valid_literal
                   puts
                   puts "Checking git remote 'origin' to derive GitHub homepage..."
-                  origin_url = nil
+                  origin_url = ""
+                  # Use GitAdapter to avoid hanging and to simplify testing.
                   begin
-                    origin_cmd = ["git", "-C", project_root.to_s, "remote", "get-url", "origin"]
-                    origin_out = IO.popen(origin_cmd, &:read)
-                    origin_out = origin_out.read if origin_out.respond_to?(:read)
-                    origin_url = origin_out.to_s.strip
-                  rescue StandardError
-                    origin_url = ""
+                    ga = Kettle::Dev::GitAdapter.new
+                    origin_url = ga.remote_url("origin") || ga.remotes_with_urls["origin"]
+                    origin_url = origin_url.to_s.strip
+                  rescue StandardError => e
+                    Kettle::Dev.debug_error(e, __method__)
                   end
 
                   org_repo = github_repo_from_url.call(origin_url)
@@ -363,7 +367,7 @@ module Kettle
                   puts "Suggested literal homepage: \"#{suggested}\""
                   print("Update #{File.basename(gemspec_path)} to use this homepage? [Y/n]: ")
                   ans = Kettle::Dev::InputAdapter.gets&.strip
-                  do_update = if ENV.fetch("force", "").to_s =~ /\A(1|true|y|yes)\z/i
+                  do_update = if ENV.fetch("force", "").to_s =~ ENV_TRUE_RE
                     true
                   else
                     ans.nil? || ans.empty? || ans =~ /\Ay(es)?\z/i
@@ -440,7 +444,8 @@ module Kettle
           else
             begin
               current = File.file?(envrc_path) ? File.read(envrc_path) : ""
-            rescue StandardError
+            rescue StandardError => e
+              Kettle::Dev.debug_error(e, __method__)
               current = ""
             end
             has_path_add = current.lines.any? { |l| l.strip =~ /^PATH_add\s+bin\b/ }
@@ -468,8 +473,8 @@ module Kettle
           end
 
           if defined?(updated_envrc_by_install) && updated_envrc_by_install
-            allowed_truthy = ENV.fetch("allowed", "").to_s =~ /\A(1|true|y|yes)\z/i
-            force_truthy = ENV.fetch("force", "").to_s =~ /\A(1|true|y|yes)\z/i
+            allowed_truthy = ENV.fetch("allowed", "").to_s =~ ENV_TRUE_RE
+            force_truthy = ENV.fetch("force", "").to_s =~ ENV_TRUE_RE
             if allowed_truthy || force_truthy
               reason = allowed_truthy ? "allowed=true" : "force=true"
               puts "Proceeding after .envrc update because #{reason}."
@@ -496,7 +501,8 @@ module Kettle
           unless helpers.modified_by_template?(gitignore_path)
             begin
               gitignore_current = File.exist?(gitignore_path) ? File.read(gitignore_path) : ""
-            rescue StandardError
+            rescue StandardError => e
+              Kettle::Dev.debug_error(e, __method__)
               gitignore_current = ""
             end
             has_env_local = gitignore_current.lines.any? { |l| l.strip == ".env.local" }
@@ -505,7 +511,7 @@ module Kettle
               puts "Would you like to add '.env.local' to #{gitignore_path}?"
               print("Add to .gitignore now [Y/n]: ")
               answer = Kettle::Dev::InputAdapter.gets&.strip
-              add_it = if ENV.fetch("force", "").to_s =~ /\A(1|true|y|yes)\z/i
+              add_it = if ENV.fetch("force", "").to_s =~ ENV_TRUE_RE
                 true
               else
                 answer.nil? || answer.empty? || answer =~ /\Ay(es)?\z/i

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

@@ -63,6 +63,7 @@ module Kettle
                   helpers.apply_common_replacements(
                     c,
                     org: forge_org,
+                    funding_org: funding_org,
                     gem_name: gem_name,
                     namespace: namespace,
                     namespace_shield: namespace_shield,
@@ -74,6 +75,7 @@ module Kettle
                   helpers.apply_common_replacements(
                     content,
                     org: forge_org,
+                    funding_org: funding_org,
                     gem_name: gem_name,
                     namespace: namespace,
                     namespace_shield: namespace_shield,
@@ -209,21 +211,29 @@ module Kettle
               if File.exist?(dest_gemspec)
                 begin
                   orig_meta = helpers.gemspec_metadata(File.dirname(dest_gemspec))
-                rescue StandardError
+                rescue StandardError => e
+                  Kettle::Dev.debug_error(e, __method__)
                   orig_meta = nil
                 end
               end
 
               helpers.copy_file_with_prompt(gemspec_template_src, dest_gemspec, allow_create: true, allow_replace: true) do |content|
-                # First apply standard replacements from the template example
-                c = helpers.apply_common_replacements(
-                  content,
-                  org: forge_org,
-                  gem_name: gem_name,
-                  namespace: namespace,
-                  namespace_shield: namespace_shield,
-                  gem_shield: gem_shield,
-                )
+                # First apply standard replacements from the template example, but only
+                # when we have a usable gem_name. If gem_name is unknown, leave content as-is
+                # to allow filename fallback behavior without raising.
+                c = if gem_name && !gem_name.to_s.empty?
+                  helpers.apply_common_replacements(
+                    content,
+                    org: forge_org,
+                    funding_org: funding_org,
+                    gem_name: gem_name,
+                    namespace: namespace,
+                    namespace_shield: namespace_shield,
+                    gem_shield: gem_shield,
+                  )
+                else
+                  content.dup
+                end
 
                 if orig_meta
                   # Replace a scalar string assignment like: spec.field = "..."
@@ -311,10 +321,32 @@ module Kettle
                   end
                 end
 
+                # Ensure we do not introduce a self-dependency when templating the gemspec.
+                # If the template included a dependency on the template gem (e.g., "kettle-dev"),
+                # the common replacements would have turned it into the destination gem's name.
+                # Strip any dependency lines that name the destination gem.
+                begin
+                  if gem_name && !gem_name.to_s.empty?
+                    name_escaped = Regexp.escape(gem_name)
+                    # Matches both runtime and development dependency lines, with or without parentheses.
+                    # Examples matched:
+                    #   spec.add_dependency("my-gem", "~> 1.0")
+                    #   spec.add_dependency 'my-gem'
+                    #   spec.add_development_dependency "my-gem"
+                    #   spec.add_development_dependency 'my-gem', ">= 0"
+                    self_dep_re = /\A\s*spec\.add_(?:development_)?dependency(?:\s*\(|\s+)\s*["']#{name_escaped}["'][^\n]*\)?\s*\z/
+                    c = c.lines.reject { |ln| self_dep_re =~ ln }.join
+                  end
+                rescue StandardError => e
+                  Kettle::Dev.debug_error(e, __method__)
+                  # If anything goes wrong, keep the content as-is rather than failing the task
+                end
+
                 c
               end
             end
-          rescue StandardError
+          rescue StandardError => e
+            Kettle::Dev.debug_error(e, __method__)
             # Do not fail the entire template task if gemspec copy has issues
           end
 
@@ -349,7 +381,8 @@ module Kettle
           existing_readme_before = begin
             path = File.join(project_root, "README.md")
             File.file?(path) ? File.read(path) : nil
-          rescue StandardError
+          rescue StandardError => e
+            Kettle::Dev.debug_error(e, __method__)
             nil
           end
 
@@ -372,7 +405,7 @@ module Kettle
                     loop do
                       cluster = s[/\A\X/u]
                       break if cluster.nil? || cluster.empty?
-                      if emoji_re.match?(cluster)
+                      if emoji_re =~ cluster
                         out << cluster
                         s = s[cluster.length..-1].to_s
                       else
@@ -397,6 +430,7 @@ module Kettle
                 c = helpers.apply_common_replacements(
                   content,
                   org: forge_org,
+                  funding_org: funding_org,
                   gem_name: gem_name,
                   namespace: namespace,
                   namespace_shield: namespace_shield,
@@ -539,7 +573,8 @@ module Kettle
               helpers.copy_file_with_prompt(src, dest, allow_create: true, allow_replace: true) do |content|
                 c = helpers.apply_common_replacements(
                   content,
-                  org: ((File.basename(rel) == ".opencollective.yml" || File.basename(rel) == "FUNDING.md") ? funding_org : forge_org),
+                  org: forge_org,
+                  funding_org: funding_org,
                   gem_name: gem_name,
                   namespace: namespace,
                   namespace_shield: namespace_shield,
@@ -581,7 +616,8 @@ module Kettle
                 end
               end
             end
-          rescue StandardError
+          rescue StandardError => e
+            Kettle::Dev.debug_error(e, __method__)
             # ignore post-processing errors
           end
 
@@ -656,13 +692,15 @@ module Kettle
                   end
                 end
               end
-            rescue StandardError
+            rescue StandardError => e
+              Kettle::Dev.debug_error(e, __method__)
               # If filter parsing fails, proceed as before
             end
-            goalie_src = File.join(source_hooks_dir, "commit-subjects-goalie.txt")
-            footer_src = File.join(source_hooks_dir, "footer-template.erb.txt")
-            hook_ruby_src = File.join(source_hooks_dir, "commit-msg")
-            hook_sh_src = File.join(source_hooks_dir, "prepare-commit-msg")
+            # Prefer .example variant when present for .git-hooks
+            goalie_src = helpers.prefer_example(File.join(source_hooks_dir, "commit-subjects-goalie.txt"))
+            footer_src = helpers.prefer_example(File.join(source_hooks_dir, "footer-template.erb.txt"))
+            hook_ruby_src = helpers.prefer_example(File.join(source_hooks_dir, "commit-msg"))
+            hook_sh_src = helpers.prefer_example(File.join(source_hooks_dir, "prepare-commit-msg"))
 
             # First: templates (.txt) — ask local/global/skip
             if File.file?(goalie_src) && File.file?(footer_src)
@@ -708,7 +746,8 @@ module Kettle
                   # Ensure readable (0644). These are data/templates, not executables.
                   begin
                     File.chmod(0o644, dest) if File.exist?(dest)
-                  rescue StandardError
+                  rescue StandardError => e
+                    Kettle::Dev.debug_error(e, __method__)
                     # ignore permission issues
                   end
                 end
@@ -733,7 +772,8 @@ module Kettle
                       helpers.write_file(dest, content)
                       begin
                         File.chmod(mode, dest)
-                      rescue StandardError
+                      rescue StandardError => e
+                        Kettle::Dev.debug_error(e, __method__)
                         # ignore permission issues
                       end
                       puts "Replaced #{dest}"
@@ -745,7 +785,8 @@ module Kettle
                     helpers.write_file(dest, content)
                     begin
                       File.chmod(mode, dest)
-                    rescue StandardError
+                    rescue StandardError => e
+                      Kettle::Dev.debug_error(e, __method__)
                       # ignore permission issues
                     end
                     puts "Installed #{dest}"

data/lib/kettle/dev/template_helpers.rb

@@ -12,6 +12,8 @@ module Kettle
       # Values: Hash with keys: :action (Symbol, one of :create, :replace, :skip, :dir_create, :dir_replace), :timestamp (Time)
       @@template_results = {}
 
+      EXECUTABLE_GIT_HOOKS_RE = %r{[\\/]\.git-hooks[\\/](commit-msg|prepare-commit-msg)\z}
+
       module_function
 
       # Root of the host project where Rake was invoked
@@ -119,9 +121,11 @@ module Kettle
         end
 
         if clean.nil?
-          # Fallback to shelling out to get both status and preview
+          # Fallback to using the GitAdapter to get both status and preview
           status_output = begin
-            IO.popen(["git", "-C", root.to_s, "status", "--porcelain"], &:read).to_s
+            ga = Kettle::Dev::GitAdapter.new
+            out, ok = ga.capture(["-C", root.to_s, "status", "--porcelain"]) # adapter can use CLI safely
+            ok ? out.to_s : ""
           rescue StandardError => e
             Kettle::Dev.debug_error(e, __method__)
             ""
@@ -130,9 +134,11 @@ module Kettle
           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
+          # For messaging, provide a small preview using GitAdapter even when using the adapter
           status_output = begin
-            IO.popen(["git", "-C", root.to_s, "status", "--porcelain"], &:read).to_s
+            ga = Kettle::Dev::GitAdapter.new
+            out, ok = ga.capture(["-C", root.to_s, "status", "--porcelain"]) # read-only query
+            ok ? out.to_s : ""
           rescue StandardError => e
             Kettle::Dev.debug_error(e, __method__)
             ""
@@ -223,10 +229,11 @@ module Kettle
         write_file(dest_path, content)
         begin
           # Ensure executable bit for git hook scripts when writing under .git-hooks
-          if dest_path.to_s.match?(%r{[\\/]\.git-hooks[\\/](commit-msg|prepare-commit-msg)\z})
+          if EXECUTABLE_GIT_HOOKS_RE =~ dest_path.to_s
             File.chmod(0o755, dest_path) if File.exist?(dest_path)
           end
-        rescue StandardError
+        rescue StandardError => e
+          Kettle::Dev.debug_error(e, __method__)
           # ignore permission issues
         end
         record_template_result(dest_path, dest_exists ? :replace : :create)
@@ -327,10 +334,11 @@ module Kettle
                 begin
                   # Ensure executable bit for git hook scripts when copying under .git-hooks
                   if target.end_with?("/.git-hooks/commit-msg", "/.git-hooks/prepare-commit-msg") ||
-                      target.match?(%r{[\\/]\.git-hooks[\\/](commit-msg|prepare-commit-msg)\z})
+                      EXECUTABLE_GIT_HOOKS_RE =~ target
                     File.chmod(0o755, target)
                   end
-                rescue StandardError
+                rescue StandardError => e
+                  Kettle::Dev.debug_error(e, __method__)
                   # ignore permission issues
                 end
               end
@@ -374,10 +382,11 @@ module Kettle
               begin
                 # Ensure executable bit for git hook scripts when copying under .git-hooks
                 if target.end_with?("/.git-hooks/commit-msg", "/.git-hooks/prepare-commit-msg") ||
-                    target.match?(%r{[\\/]\.git-hooks[\\/](commit-msg|prepare-commit-msg)\z})
+                    EXECUTABLE_GIT_HOOKS_RE =~ target
                   File.chmod(0o755, target)
                 end
-              rescue StandardError
+              rescue StandardError => e
+                Kettle::Dev.debug_error(e, __method__)
                 # ignore permission issues
               end
             end
@@ -394,30 +403,34 @@ module Kettle
       # @param namespace [String]
       # @param namespace_shield [String]
       # @param gem_shield [String]
+      # @param funding_org [String, nil]
       # @return [String]
-      def apply_common_replacements(content, org:, gem_name:, namespace:, namespace_shield:, gem_shield:)
-        c = content.dup
-        c = c.gsub("kettle-rb", org.to_s) if org && !org.empty?
-        if gem_name && !gem_name.empty?
-          # Special-case: yard-head link uses the gem name as a subdomain and must be dashes-only.
-          # Apply this BEFORE other generic replacements so it isn't altered incorrectly.
-          begin
-            dashed = gem_name.tr("_", "-")
-            c = c.gsub("[🚎yard-head]: https://kettle-dev.galtzo.com", "[🚎yard-head]: https://#{dashed}.galtzo.com")
-          rescue StandardError
-            # ignore
-          end
+      def apply_common_replacements(content, org:, gem_name:, namespace:, namespace_shield:, gem_shield:, funding_org: nil)
+        raise Error, "Org could not be derived" unless org && !org.empty?
+        raise Error, "Gem name could not be derived" unless gem_name && !gem_name.empty?
 
-          # Replace occurrences of the template gem name in text, including inside
-          # markdown reference labels like [🖼️kettle-dev] and identifiers like kettle-dev-i
-          c = c.gsub("kettle-dev", gem_name)
-          c = c.gsub(/\bKettle::Dev\b/u, namespace) unless namespace.empty?
-          c = c.gsub("Kettle%3A%3ADev", namespace_shield) unless namespace_shield.empty?
-          c = c.gsub("kettle--dev", gem_shield)
-          # Replace require and path structures with gem_name, modifying - to / if needed
-          c = c.gsub("kettle/dev", gem_name.tr("-", "/"))
+        funding_org ||= org
+        c = content.dup
+        c = c.gsub("kettle-rb", org.to_s)
+        c = c.gsub("{OPENCOLLECTIVE|ORG_NAME}", funding_org)
+        # Special-case: yard-head link uses the gem name as a subdomain and must be dashes-only.
+        # Apply this BEFORE other generic replacements so it isn't altered incorrectly.
+        begin
+          dashed = gem_name.tr("_", "-")
+          c = c.gsub("[🚎yard-head]: https://kettle-dev.galtzo.com", "[🚎yard-head]: https://#{dashed}.galtzo.com")
+        rescue StandardError => e
+          Kettle::Dev.debug_error(e, __method__)
+          # ignore
         end
-        c
+
+        # Replace occurrences of the template gem name in text, including inside
+        # markdown reference labels like [🖼️kettle-dev] and identifiers like kettle-dev-i
+        c = c.gsub("kettle-dev", gem_name)
+        c = c.gsub(/\bKettle::Dev\b/u, namespace) unless namespace.empty?
+        c = c.gsub("Kettle%3A%3ADev", namespace_shield) unless namespace_shield.empty?
+        c = c.gsub("kettle--dev", gem_shield)
+        # Replace require and path structures with gem_name, modifying - to / if needed
+        c.gsub("kettle/dev", gem_name.tr("-", "/"))
       end
 
       # Parse gemspec metadata and derive useful strings