kettle-dev 1.1.11 → 1.1.13

data/lib/kettle/dev/release_cli.rb

@@ -283,6 +283,7 @@ module Kettle
         # 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 }
         return unless m
+
         denom = m.match(/-\s*COVERAGE:\s*.+--\s*\d+\/(\d+)\s+lines/i)[1].to_i
         kloc = denom.to_f / 1000.0
         kloc_str = format("%.3f", kloc)
@@ -296,6 +297,7 @@ module Kettle
       # Replaces only the numeric portion after "KLOC-" keeping other URL parts intact.
       def update_badge_number_in_file(path, kloc_str)
         return unless File.file?(path)
+
         content = File.read(path)
         # Match the specific reference line, capture groups around the number
         # Example: [🧮kloc-img]: https://img.shields.io/badge/KLOC-2.175-FFDD67.svg?style=...
@@ -310,6 +312,7 @@ module Kettle
       def update_rakefile_example_header!(version)
         path = File.join(@root, "Rakefile.example")
         return unless File.file?(path)
+
         content = File.read(path)
         today = Time.now.strftime("%Y-%m-%d")
         new_line = "# kettle-dev Rakefile v#{version} - #{today}"
@@ -394,6 +397,7 @@ module Kettle
       def collapse_years(enum)
         arr = enum.to_a.map(&:to_i).uniq.sort
         return "" if arr.empty?
+
         segments = []
         start = arr.first
         prev = start
@@ -422,10 +426,12 @@ module Kettle
           unless line =~ /copyright/i
             next line
           end
+
           m = line.match(/\A(?<pre>.*?copyright[^0-9]*)(?<years>(?:\b(?:19|20)\d{2}\b(?:\s*[\-–]\s*\b(?:19|20)\d{2}\b)?)(?:\s*,\s*\b(?:19|20)\d{2}\b(?:\s*[\-–]\s*\b(?:19|20)\d{2}\b)?)*)(?<post>.*)\z/i)
           unless m
             next line
           end
+
           new_line = "#{m[:pre]}#{canonical_all}#{m[:post]}"
           changed ||= (new_line != line)
           new_line
@@ -444,12 +450,14 @@ module Kettle
           unless line =~ /copyright/i
             next line
           end
+
           # Capture three parts: prefix up to first year, the year blob, and the rest
           m = line.match(/\A(?<pre>.*?copyright[^0-9]*)(?<years>(?:\b(?:19|20)\d{2}\b(?:\s*[\-–]\s*\b(?:19|20)\d{2}\b)?)(?:\s*,\s*\b(?:19|20)\d{2}\b(?:\s*[\-–]\s*\b(?:19|20)\d{2}\b)?)*)(?<post>.*)\z/i)
           unless m
             # No parsable year sequence on this line; leave as-is
             next line
           end
+
           years_blob = m[:years]
           # Reuse extraction logic on just the years blob
           years = []
@@ -731,15 +739,18 @@ module Kettle
       def preferred_github_remote
         cands = github_remote_candidates
         return if cands.empty?
+
         # Prefer explicitly named GitHub remotes first, then origin (only if it points to GitHub), else the first candidate
         explicit = cands.find { |n| n == "github" } || cands.find { |n| n == "gh" }
         return explicit if explicit
         return "origin" if cands.include?("origin")
+
         cands.first
       end
 
       def parse_github_owner_repo(url)
         return [nil, nil] unless url
+
         if url =~ %r{git@github.com:(.+?)/(.+?)(\.git)?$}
           [Regexp.last_match(1), Regexp.last_match(2).sub(/\.git\z/, "")]
         elsif url =~ %r{https://github.com/(.+?)/(.+?)(\.git)?$}
@@ -761,6 +772,7 @@ module Kettle
       def ahead_behind_counts(local_ref, remote_ref)
         out, ok = git_output(["rev-list", "--left-right", "--count", "#{local_ref}...#{remote_ref}"])
         return [0, 0] unless ok && !out.empty?
+
         parts = out.split
         left = parts[0].to_i
         right = parts[1].to_i
@@ -769,6 +781,7 @@ module Kettle
 
       def trunk_behind_remote?(trunk, remote)
         return false unless remote_branch_exists?(remote, trunk)
+
         _ahead, behind = ahead_behind_counts(trunk, "#{remote}/#{trunk}")
         behind.positive?
       end
@@ -781,6 +794,7 @@ module Kettle
           missing_from = []
           remotes.each do |r|
             next if r == "all"
+
             if remote_branch_exists?(r, trunk)
               _ahead, behind = ahead_behind_counts(trunk, "#{r}/#{trunk}")
               missing_from << r if behind.positive?
@@ -853,6 +867,7 @@ module Kettle
 
       def merge_feature_into_trunk_and_push!(trunk, feature)
         return if feature.nil? || feature == trunk
+
         puts "Merging #{feature} into #{trunk} (after CI success)..."
         checkout!(trunk)
         run_cmd!("git pull --rebase origin #{Shellwords.escape(trunk)}")
@@ -971,12 +986,14 @@ module Kettle
       def extract_changelog_for_version(version)
         path = File.join(@root, "CHANGELOG.md")
         return [nil, nil, nil] unless File.file?(path)
+
         content = File.read(path)
         lines = content.lines
 
         # Find section start
         start_idx = lines.index { |l| l.start_with?("## [#{version}]") }
         return [nil, nil, nil] unless start_idx
+
         i = start_idx + 1
         # Find next section heading or EOF
         while i < lines.length && !lines[i].start_with?("## [")
@@ -999,12 +1016,14 @@ module Kettle
       def extract_release_notes_footer
         path = File.join(@root, "FUNDING.md")
         return unless File.file?(path)
+
         content = File.read(path)
         start_tag = "<!-- RELEASE-NOTES-FOOTER-START -->"
         end_tag = "<!-- RELEASE-NOTES-FOOTER-END -->"
         s = content.index(start_tag)
         e = content.index(end_tag)
         return unless s && e && e > s
+
         # Extract between tags, excluding the tags themselves
         block = content[(s + start_tag.length)...e]
         # Normalize: trim trailing whitespace but keep internal formatting

data/lib/kettle/dev/setup_cli.rb

@@ -31,6 +31,8 @@ module Kettle
         say("Starting kettle-dev setup…")
         prechecks!
         ensure_dev_deps!
+        ensure_gemfile_from_example!
+        ensure_modular_gemfiles!
         ensure_bin_setup!
         ensure_rakefile!
         run_bin_setup!
@@ -44,14 +46,72 @@ module Kettle
 
       def debug(msg)
         return if ENV.fetch("DEBUG", "false").casecmp("true").nonzero?
+
         $stderr.puts("[kettle-dev-setup] DEBUG: #{msg}")
       end
 
+      # Attempt to derive a funding organization from the git remote 'origin' when
+      # not explicitly provided via env or .opencollective.yml.
+      # This is a soft helper that only sets ENV["FUNDING_ORG"] if a plausible
+      # GitHub org can be parsed from the origin URL.
+      # @return [void]
+      def derive_funding_org_from_git_if_missing!
+        # Respect explicit bypass
+        env_val = ENV["FUNDING_ORG"]
+        return if env_val && env_val.to_s.strip.casecmp("false").zero?
+
+        # If already provided via env, do nothing
+        return if ENV["FUNDING_ORG"].to_s.strip != ""
+        return if ENV["OPENCOLLECTIVE_HANDLE"].to_s.strip != ""
+
+        # If project provides an .opencollective.yml with org, do nothing
+        begin
+          oc_path = File.join(Dir.pwd, ".opencollective.yml")
+          if File.file?(oc_path)
+            txt = File.read(oc_path)
+            return if txt =~ /\borg:\s*([\w\-]+)/i
+          end
+        rescue StandardError => e
+          debug("Reading .opencollective.yml failed: #{e.class}: #{e.message}")
+        end
+
+        # Attempt to get origin URL and parse GitHub org
+        begin
+          ga = Kettle::Dev::GitAdapter.new
+          origin_url = nil
+          origin_url = ga.remote_url("origin") if ga.respond_to?(:remote_url)
+          if origin_url.nil? && ga.respond_to?(:remotes_with_urls)
+            begin
+              urls = ga.remotes_with_urls
+              origin_url = urls["origin"] if urls
+            rescue StandardError => e
+              # graceful fallback if adapter backend errs; keep silent behavior
+              debug("remotes_with_urls failed: #{e.class}: #{e.message}")
+            end
+          end
+          origin_url = origin_url.to_s.strip
+          if (m = origin_url.match(%r{github\.com[/:]([^/]+)/}i))
+            org = m[1].to_s
+            if !org.empty?
+              ENV["FUNDING_ORG"] = org
+              debug("Derived FUNDING_ORG from git origin: #{org}")
+            end
+          end
+        rescue StandardError => e
+          # Be silent; this is a best-effort and shouldn't fail setup
+          debug("Could not derive funding org from git: #{e.class}: #{e.message}")
+        end
+      end
+
       def parse!
         parser = OptionParser.new do |opts|
           opts.banner = "Usage: kettle-dev-setup [options]"
           opts.on("--allowed=VAL", "Pass through to kettle:dev:install") { |v| @passthrough << "allowed=#{v}" }
-          opts.on("--force", "Pass through to kettle:dev:install") { @passthrough << "force=true" }
+          opts.on("--force", "Pass through to kettle:dev:install") do
+            # Ensure in-process helpers (TemplateHelpers.ask) also see force mode
+            ENV["force"] = "true"
+            @passthrough << "force=true"
+          end
           opts.on("--hook_templates=VAL", "Pass through to kettle:dev:install") { |v| @passthrough << "hook_templates=#{v}" }
           opts.on("--only=VAL", "Pass through to kettle:dev:install") { |v| @passthrough << "only=#{v}" }
           opts.on("-h", "--help", "Show help") do
@@ -110,6 +170,9 @@ module Kettle
 
         # Gemfile
         abort!("No Gemfile found; bundler is required.") unless File.exist?("Gemfile")
+
+        # Seed FUNDING_ORG from git remote origin org when not provided elsewhere
+        derive_funding_org_from_git_if_missing!
       end
 
       # 3. Sync dev dependencies from this gem's example gemspec into target gemspec
@@ -181,6 +244,103 @@ module Kettle
         say("Copied bin/setup.")
       end
 
+      # 3b. Ensure Gemfile contains required lines from example without duplicating directives
+      #    - Copies source, git_source, gemspec, and eval_gemfile lines that are missing
+      #    - Idempotent (running multiple times does not duplicate entries)
+      def ensure_gemfile_from_example!
+        source_path = installed_path("Gemfile.example")
+        abort!("Internal error: Gemfile.example not found within installed gem.") unless source_path && File.exist?(source_path)
+
+        example = File.read(source_path)
+        target_path = "Gemfile"
+        target = File.exist?(target_path) ? File.read(target_path) : ""
+
+        # Extract interesting lines from example
+        ex_sources = []
+        ex_git_sources = [] # names (e.g., :github)
+        ex_git_source_lines = {}
+        ex_has_gemspec = false
+        ex_eval_paths = []
+
+        example.each_line do |ln|
+          s = ln.strip
+          next if s.empty?
+
+          if s.start_with?("source ")
+            ex_sources << ln.rstrip
+          elsif (m = s.match(/^git_source\(\s*:(\w+)\s*\)/))
+            name = m[1]
+            ex_git_sources << name
+            ex_git_source_lines[name] = ln.rstrip
+          elsif s.start_with?("gemspec")
+            ex_has_gemspec = true
+          elsif (m = s.match(/^eval_gemfile\s+["']([^"']+)["']/))
+            ex_eval_paths << m[1]
+          end
+        end
+
+        # Scan target for presence
+        tg_sources = target.each_line.map(&:rstrip).select { |l| l.strip.start_with?("source ") }
+        tg_git_sources = {}
+        target.each_line do |ln|
+          if (m = ln.strip.match(/^git_source\(\s*:(\w+)\s*\)/))
+            tg_git_sources[m[1]] = true
+          end
+        end
+        tg_has_gemspec = !!target.each_line.find { |l| l.strip.start_with?("gemspec") }
+        tg_eval_paths = target.each_line.map do |ln|
+          if (m = ln.strip.match(/^eval_gemfile\s+["']([^"']+)["']/))
+            m[1]
+          end
+        end.compact
+
+        additions = []
+        # Add missing sources (exact line match)
+        ex_sources.each do |src_line|
+          additions << src_line unless tg_sources.include?(src_line)
+        end
+        # Add missing git_source by name
+        ex_git_sources.each do |name|
+          additions << ex_git_source_lines[name] unless tg_git_sources[name]
+        end
+        # Add gemspec if example has it and target lacks it
+        additions << "gemspec" if ex_has_gemspec && !tg_has_gemspec
+        # Add missing eval_gemfile paths (recreate the exact example line when possible)
+        ex_eval_paths.each do |path|
+          next if tg_eval_paths.include?(path)
+
+          additions << "eval_gemfile \"#{path}\""
+        end
+
+        return say("Gemfile already contains required entries from example.") if additions.empty?
+
+        # Ensure file ends with a newline
+        target << "\n" unless target.end_with?("\n") || target.empty?
+        new_content = target + additions.join("\n") + "\n"
+        File.write(target_path, new_content)
+        say("Updated Gemfile with entries from Gemfile.example (added #{additions.size}).")
+      end
+
+      # 3c. Ensure gemfiles/modular/* are present (copied like template task)
+      def ensure_modular_gemfiles!
+        helpers = Kettle::Dev::TemplateHelpers
+        project_root = helpers.project_root
+        gem_checkout_root = helpers.gem_checkout_root
+        # Gather min_ruby for style.gemfile adjustments
+        min_ruby = begin
+          md = helpers.gemspec_metadata(project_root)
+          md[:min_ruby]
+        rescue StandardError
+          nil
+        end
+        Kettle::Dev::ModularGemfiles.sync!(
+          helpers: helpers,
+          project_root: project_root,
+          gem_checkout_root: gem_checkout_root,
+          min_ruby: min_ruby,
+        )
+      end
+
       # 5. Ensure Rakefile matches example (replace or create)
       def ensure_rakefile!
         source = installed_path("Rakefile.example")
@@ -245,6 +405,7 @@ module Kettle
         here = File.expand_path(File.join(__dir__, "..", "..", "..")) # lib/kettle/dev/ -> project root
         path = File.join(here, rel)
         return path if File.exist?(path)
+
         nil
       end
     end

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

@@ -174,14 +174,19 @@ module Kettle
                 end
               end
 
-              # If no grapheme found in README H1, ask the user which to use
+              # If no grapheme found in README H1, either use a default in force mode, or ask the user.
               if chosen_grapheme.nil? || chosen_grapheme.empty?
-                puts "No grapheme found after README H1. Enter a grapheme (emoji/symbol) to use for README, summary, and description:"
-                print("Grapheme: ")
-                ans = Kettle::Dev::InputAdapter.gets&.strip.to_s
-                chosen_grapheme = ans[/\A\X/u].to_s
-                # If still empty, skip synchronization silently
-                chosen_grapheme = nil if chosen_grapheme.empty?
+                if ENV.fetch("force", "").to_s =~ ENV_TRUE_RE
+                  # Non-interactive install: default to pizza slice to match template style.
+                  chosen_grapheme = "🍕"
+                else
+                  puts "No grapheme found after README H1. Enter a grapheme (emoji/symbol) to use for README, summary, and description:"
+                  print("Grapheme: ")
+                  ans = Kettle::Dev::InputAdapter.gets&.strip.to_s
+                  chosen_grapheme = ans[/\A\X/u].to_s
+                  # If still empty, skip synchronization silently
+                  chosen_grapheme = nil if chosen_grapheme.empty?
+                end
               end
 
               if chosen_grapheme
@@ -311,15 +316,18 @@ module Kettle
 
                 github_repo_from_url = lambda do |url|
                   return unless url
+
                   url = url.strip
                   m = url.match(%r{github\.com[/:]([^/\s:]+)/([^/\s]+?)(?:\.git)?/?\z}i)
                   return unless m
+
                   [m[1], m[2]]
                 end
 
                 github_homepage_literal = lambda do |val|
                   return false unless val
                   return false if val.include?('#{')
+
                   v = val.to_s.strip
                   if (v.start_with?("\"") && v.end_with?("\"")) || (v.start_with?("'") && v.end_with?("'"))
                     v = begin
@@ -329,6 +337,7 @@ module Kettle
                     end
                   end
                   return false unless v =~ %r{\Ahttps?://github\.com/}i
+
                   !!github_repo_from_url.call(v)
                 end
 
@@ -364,12 +373,13 @@ module Kettle
                   puts "Current spec.homepage appears #{interpolated ? "interpolated" : "invalid"}: #{assigned}"
                   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 =~ ENV_TRUE_RE
-                    true
-                  else
-                    ans.nil? || ans.empty? || ans =~ /\Ay(es)?\z/i
-                  end
+                  do_update =
+                    if ENV.fetch("force", "").to_s =~ ENV_TRUE_RE
+                      true
+                    else
+                      ans = Kettle::Dev::InputAdapter.gets&.strip
+                      ans.nil? || ans.empty? || ans =~ /\Ay(es)?\z/i
+                    end
 
                   if do_update
                     new_line = homepage_line.sub(/=.*/, "= \"#{suggested}\"\n")
@@ -385,6 +395,7 @@ module Kettle
           rescue StandardError => e
             # Do not swallow intentional task aborts signaled via Kettle::Dev::Error
             raise if e.is_a?(Kettle::Dev::Error)
+
             puts "WARNING: An error occurred while checking gemspec homepage: #{e.class}: #{e.message}"
           end
 
@@ -406,6 +417,7 @@ module Kettle
               [:create, :replace, :dir_create, :dir_replace].each do |sym|
                 items = meaningful.select { |_, rec| rec[:action] == sym }.map { |path, _| path }
                 next if items.empty?
+
                 puts "  #{action_labels[sym]}:"
                 items.sort.each do |abs|
                   rel = begin
@@ -472,10 +484,8 @@ module Kettle
 
           if defined?(updated_envrc_by_install) && updated_envrc_by_install
             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}."
+            if allowed_truthy
+              puts "Proceeding after .envrc update because allowed=true."
             else
               puts
               puts "IMPORTANT: .envrc was updated during kettle:dev:install."
@@ -509,7 +519,10 @@ 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 =~ ENV_TRUE_RE
+              # Respect an explicit negative answer even when force=true
+              add_it = if answer && answer =~ /\An(o)?\z/i
+                false
+              elsif 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

@@ -104,91 +104,13 @@ module Kettle
             allow_replace: true,
           )
 
-          # 4a) gemfiles/modular/*.gemfile
-          #     from gem's gemfiles/modular,
-          #     except `style.gemfile` which has special handling below
-          modular_gemfiles = %w[
-            coverage
-            debug
-            documentation
-            injected
-            optional
-            runtime_heads
-            x_std_libs
-          ]
-          modular_gemfiles.each do |base|
-            modular_gemfile = "#{base}.gemfile"
-            src = helpers.prefer_example(File.join(gem_checkout_root, MODULAR_GEMFILE_DIR, modular_gemfile))
-            dest = File.join(project_root, MODULAR_GEMFILE_DIR, modular_gemfile)
-            helpers.copy_file_with_prompt(src, dest, allow_create: true, allow_replace: true)
-          end
-
-          # 4b) gemfiles/modular/style.gemfile
-          modular_gemfile = "style.gemfile"
-          src = helpers.prefer_example(File.join(gem_checkout_root, MODULAR_GEMFILE_DIR, modular_gemfile))
-          dest = File.join(project_root, MODULAR_GEMFILE_DIR, modular_gemfile)
-          if File.basename(src).sub(/\.example\z/, "") == "style.gemfile"
-            helpers.copy_file_with_prompt(src, dest, allow_create: true, allow_replace: true) do |content|
-              # Adjust rubocop-lts constraint based on min_ruby
-              version_map = [
-                [Gem::Version.new("1.8"), "~> 0.1"],
-                [Gem::Version.new("1.9"), "~> 2.0"],
-                [Gem::Version.new("2.0"), "~> 4.0"],
-                [Gem::Version.new("2.1"), "~> 6.0"],
-                [Gem::Version.new("2.2"), "~> 8.0"],
-                [Gem::Version.new("2.3"), "~> 10.0"],
-                [Gem::Version.new("2.4"), "~> 12.0"],
-                [Gem::Version.new("2.5"), "~> 14.0"],
-                [Gem::Version.new("2.6"), "~> 16.0"],
-                [Gem::Version.new("2.7"), "~> 18.0"],
-                [Gem::Version.new("3.0"), "~> 20.0"],
-                [Gem::Version.new("3.1"), "~> 22.0"],
-                [Gem::Version.new("3.2"), "~> 24.0"],
-                [Gem::Version.new("3.3"), "~> 26.0"],
-                [Gem::Version.new("3.4"), "~> 28.0"],
-              ]
-              new_constraint = nil
-              rubocop_ruby_gem_version = nil
-              ruby1_8 = version_map.first
-              begin
-                if min_ruby
-                  version_map.reverse_each do |min, req|
-                    if min_ruby >= min
-                      new_constraint = req
-                      rubocop_ruby_gem_version = min.segments.join("_")
-                      break
-                    end
-                  end
-                end
-                if !new_constraint || !rubocop_ruby_gem_version
-                  # A gem with no declared minimum ruby is effectively >= 1.8.7
-                  new_constraint = ruby1_8[1]
-                  rubocop_ruby_gem_version = ruby1_8[0].segments.join("_")
-                end
-              rescue StandardError => e
-                Kettle::Dev.debug_error(e, __method__)
-                # ignore, use default
-              ensure
-                new_constraint ||= ruby1_8[1]
-                rubocop_ruby_gem_version ||= ruby1_8[0].segments.join("_")
-              end
-              if new_constraint && rubocop_ruby_gem_version
-                token = "{RUBOCOP|LTS|CONSTRAINT}"
-                content.gsub!(token, new_constraint) if content.include?(token)
-                token = "{RUBOCOP|RUBY|GEM}"
-                content.gsub!(token, "rubocop-ruby#{rubocop_ruby_gem_version}") if content.include?(token)
-              end
-            end
-          else
-            helpers.copy_file_with_prompt(src, dest, allow_create: true, allow_replace: true)
-          end
-
-          # 4c) Copy modular directories with nested/versioned files
-          %w[erb mutex_m stringio x_std_libs].each do |dir|
-            src_dir = File.join(gem_checkout_root, MODULAR_GEMFILE_DIR, dir)
-            dest_dir = File.join(project_root, MODULAR_GEMFILE_DIR, dir)
-            helpers.copy_dir_with_prompt(src_dir, dest_dir)
-          end
+          # 4) gemfiles/modular/* and nested directories (delegated for DRYness)
+          Kettle::Dev::ModularGemfiles.sync!(
+            helpers: helpers,
+            project_root: project_root,
+            gem_checkout_root: gem_checkout_root,
+            min_ruby: min_ruby,
+          )
 
           # 5) spec/spec_helper.rb (no create)
           dest_spec_helper = File.join(project_root, "spec/spec_helper.rb")
@@ -427,6 +349,7 @@ module Kettle
             src = helpers.prefer_example(File.join(gem_checkout_root, rel))
             dest = File.join(project_root, rel)
             next unless File.exist?(src)
+
             if File.basename(rel) == "README.md"
               # Precompute destination README H1 prefix (emoji(s) or first grapheme) before any overwrite occurs
               prev_readme = File.exist?(dest) ? File.read(dest) : nil
@@ -442,6 +365,7 @@ module Kettle
                     loop do
                       cluster = s[/\A\X/u]
                       break if cluster.nil? || cluster.empty?
+
                       if emoji_re =~ cluster
                         out << cluster
                         s = s[cluster.length..-1].to_s
@@ -481,6 +405,7 @@ module Kettle
                   # Parse Markdown headings while ignoring fenced code blocks (``` ... ```)
                   build_sections = lambda do |md|
                     return {lines: [], sections: [], line_count: 0} unless md
+
                     lines = md.split("\n", -1)
                     line_count = lines.length
 
@@ -494,6 +419,7 @@ module Kettle
                         next
                       end
                       next if in_code
+
                       if (m = ln.match(/^(#+)\s+.+/))
                         level = m[1].length
                         title = ln.sub(/^#+\s+/, "")
@@ -527,6 +453,7 @@ module Kettle
                     j = i + 1
                     while j < sections_arr.length
                       return sections_arr[j][:start] - 1 if sections_arr[j][:level] <= current[:level]
+
                       j += 1
                     end
                     total_lines - 1
@@ -542,6 +469,7 @@ module Kettle
                       base = s[:base]
                       # Only set once (first occurrence wins)
                       next if dest_lookup.key?(base)
+
                       be = branch_end_index.call(dest_parsed[:sections], idx, dest_parsed[:line_count])
                       body_lines = dest_parsed[:lines][(s[:start] + 1)..be] || []
                       dest_lookup[base] = {body_branch: body_lines.join("\n"), level: s[:level]}
@@ -563,6 +491,7 @@ module Kettle
                     # Iterate in reverse to keep indices valid
                     src_parsed[:sections].reverse_each.with_index do |sec, rev_i|
                       next unless targets.include?(sec[:base])
+
                       # Determine branch range in src for this section
                       # rev_i is reverse index; compute forward index
                       i = src_parsed[:sections].length - 1 - rev_i
@@ -730,6 +659,7 @@ module Kettle
           rescue StandardError => e
             # Do not swallow intentional task aborts
             raise if e.is_a?(Kettle::Dev::Error)
+
             puts "WARNING: Could not determine env file changes: #{e.class}: #{e.message}"
           end
 
@@ -831,6 +761,7 @@ module Kettle
             hook_pairs = [[hook_ruby_src, "commit-msg", 0o755], [hook_sh_src, "prepare-commit-msg", 0o755]]
             hook_pairs.each do |src, base, mode|
               next unless File.file?(src)
+
               hook_dests.each do |dstdir|
                 begin
                   FileUtils.mkdir_p(dstdir)

data/lib/kettle/dev/template_helpers.rb

@@ -42,9 +42,13 @@ module Kettle
         print("#{prompt} #{default ? "[Y/n]" : "[y/N]"}: ")
         ans = Kettle::Dev::InputAdapter.gets&.strip
         ans = "" if ans.nil?
+        # Normalize explicit no first
+        return false if ans =~ /\An(o)?\z/i
         if default
+          # Empty -> default true; explicit yes -> true; anything else -> false
           ans.empty? || ans =~ /\Ay(es)?\z/i
         else
+          # Empty -> default false; explicit yes -> true; others (including garbage) -> false
           ans =~ /\Ay(es)?\z/i
         end
       end

data/lib/kettle/dev/version.rb

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

data/lib/kettle/dev/versioning.rb

@@ -16,6 +16,7 @@ module Kettle
           content = File.read(path)
           m = content.match(/VERSION\s*=\s*(["'])([^"']+)\1/)
           next unless m
+
           m[2]
         end.compact
         abort!("VERSION constant not found in #{root}/lib/**/version.rb") if versions.none?
@@ -39,6 +40,7 @@ module Kettle
 
         if cmaj > pmaj
           return :epic if cmaj && cmaj > 1000
+
           :major
         elsif cmin > pmin
           :minor

data/lib/kettle/dev.rb

@@ -26,6 +26,7 @@ module Kettle
     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"