kettle-dev 1.0.9 → 1.0.10

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

@@ -0,0 +1,334 @@
+# frozen_string_literal: true
+
+# External
+require "kettle/dev/exit_adapter"
+require "open3"
+require "net/http"
+require "json"
+require "uri"
+
+module Kettle
+  module Dev
+    module Tasks
+      module CITask
+        module_function
+
+        # Local abort indirection to enable mocking via ExitAdapter
+        def abort(msg)
+          Kettle::Dev::ExitAdapter.abort(msg)
+        end
+        module_function :abort
+
+        # Runs `act` for a selected workflow. Option can be a short code or workflow basename.
+        # Mirrors the behavior previously implemented in the ci:act rake task.
+        # @param opt [String, nil]
+        def act(opt = nil)
+          require "io/console"
+          choice = opt&.strip
+
+          root_dir = Kettle::Dev::CIHelpers.project_root
+          workflows_dir = File.join(root_dir, ".github", "workflows")
+
+          # Build mapping dynamically from workflow files; short code = first three letters of filename stem
+          mapping = {}
+
+          existing_files = if Dir.exist?(workflows_dir)
+            Dir[File.join(workflows_dir, "*.yml")] + Dir[File.join(workflows_dir, "*.yaml")]
+          else
+            []
+          end
+          existing_basenames = existing_files.map { |p| File.basename(p) }
+
+          exclusions = Kettle::Dev::CIHelpers.exclusions
+          candidate_files = existing_basenames.uniq - exclusions
+          candidate_files.sort.each do |fname|
+            stem = fname.sub(/\.(ya?ml)\z/, "")
+            code = stem[0, 3].to_s.downcase
+            next if code.empty?
+            mapping[code] ||= fname
+          end
+
+          dynamic_files = candidate_files - mapping.values
+          display_code_for = {}
+          mapping.keys.each { |k| display_code_for[k] = k }
+          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
+          end
+
+          fetch_and_print_status = proc do |workflow_file|
+            branch = Kettle::Dev::CIHelpers.current_branch
+            org_repo = Kettle::Dev::CIHelpers.repo_info
+            unless branch && org_repo
+              puts "GHA status: (skipped; missing git branch or remote)"
+              next
+            end
+            owner, repo = org_repo
+            uri = URI("https://api.github.com/repos/#{owner}/#{repo}/actions/workflows/#{workflow_file}/runs?branch=#{URI.encode_www_form_component(branch)}&per_page=1")
+            req = Net::HTTP::Get.new(uri)
+            req["User-Agent"] = "ci:act rake task"
+            token = Kettle::Dev::CIHelpers.default_token
+            req["Authorization"] = "token #{token}" if token && !token.empty?
+            begin
+              res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
+              if res.is_a?(Net::HTTPSuccess)
+                data = JSON.parse(res.body)
+                run = data["workflow_runs"]&.first
+                if run
+                  status = run["status"]
+                  conclusion = run["conclusion"]
+                  emoji = status_emoji.call(status, conclusion)
+                  details = [status, conclusion].compact.join("/")
+                  puts "Latest GHA (#{branch}) for #{workflow_file}: #{emoji} (#{details})"
+                else
+                  puts "Latest GHA (#{branch}) for #{workflow_file}: none"
+                end
+              else
+                puts "GHA status: request failed (#{res.code})"
+              end
+            rescue StandardError => e
+              puts "GHA status: error #{e.class}: #{e.message}"
+            end
+          end
+
+          run_act_for = proc do |file_path|
+            ok = system("act", "-W", file_path)
+            abort("ci:act failed: 'act' command not found or exited with failure") unless ok
+          end
+
+          if choice && !choice.empty?
+            file = if mapping.key?(choice)
+              mapping.fetch(choice)
+            elsif !!(/\.(yml|yaml)\z/ =~ choice)
+              choice
+            else
+              cand_yml = File.join(workflows_dir, "#{choice}.yml")
+              cand_yaml = File.join(workflows_dir, "#{choice}.yaml")
+              if File.file?(cand_yml)
+                "#{choice}.yml"
+              elsif File.file?(cand_yaml)
+                "#{choice}.yaml"
+              else
+                "#{choice}.yml"
+              end
+            end
+            file_path = File.join(workflows_dir, file)
+            unless File.file?(file_path)
+              puts "Unknown option or missing workflow file: #{choice} -> #{file}"
+              puts "Available options:"
+              mapping.each { |k, v| puts "  #{k.ljust(3)} => #{v}" }
+              unless dynamic_files.empty?
+                puts "  (others) =>"
+                dynamic_files.each { |v| puts "        #{v}" }
+              end
+              abort("ci:act aborted")
+            end
+            fetch_and_print_status.call(file)
+            run_act_for.call(file_path)
+            return
+          end
+
+          # Interactive menu
+          require "thread"
+          tty = $stdout.tty?
+          options = mapping.to_a + dynamic_files.map { |f| [f, f] }
+          quit_code = "q"
+          options_with_quit = options + [[quit_code, "(quit)"]]
+          idx_by_code = {}
+          options_with_quit.each_with_index { |(k, _v), i| idx_by_code[k] = i }
+
+          branch = Kettle::Dev::CIHelpers.current_branch
+          org = Kettle::Dev::CIHelpers.repo_info
+          owner, repo = org if org
+          token = Kettle::Dev::CIHelpers.default_token
+
+          upstream = begin
+            out, status = Open3.capture2("git", "rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{u}")
+            status.success? ? out.strip : nil
+          rescue StandardError
+            nil
+          end
+          sha = begin
+            out, status = Open3.capture2("git", "rev-parse", "--short", "HEAD")
+            status.success? ? out.strip : nil
+          rescue StandardError
+            nil
+          end
+          if org && branch
+            puts "Repo: #{owner}/#{repo}"
+          elsif org
+            puts "Repo: #{owner}/#{repo}"
+          else
+            puts "Repo: n/a"
+          end
+          puts "Upstream: #{upstream || "n/a"}"
+          puts "HEAD: #{sha || "n/a"}"
+          puts
+          puts "Select a workflow to run with 'act':"
+
+          placeholder = "[…]"
+          options_with_quit.each_with_index do |(k, v), idx|
+            status_col = (k == quit_code) ? "" : placeholder
+            disp = (k == quit_code) ? k : display_code_for[k]
+            line = format("%2d) %-3s => %-20s %s", idx + 1, disp, v, status_col)
+            puts line
+          end
+
+          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
+
+          selected = nil
+          input_thread = Thread.new do
+            begin
+              selected = $stdin.gets&.strip
+            rescue Exception => error
+              # 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
+            end
+          end
+
+          status_q = Queue.new
+          workers = []
+          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|
+              begin
+                now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+                delay = 0.12 - (now - st_at)
+                sleep(delay) if delay && delay > 0
+
+                if ow.nil? || rp.nil? || br.nil?
+                  status_q << [c, f, "n/a"]
+                  Thread.exit
+                end
+                uri = URI("https://api.github.com/repos/#{ow}/#{rp}/actions/workflows/#{f}/runs?branch=#{URI.encode_www_form_component(br)}&per_page=1")
+                poll_interval = Integer(ENV["CI_ACT_POLL_INTERVAL"] || 5)
+                loop do
+                  begin
+                    req = Net::HTTP::Get.new(uri)
+                    req["User-Agent"] = "ci:act rake task"
+                    req["Authorization"] = "token #{tk}" if tk && !tk.empty?
+                    res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
+                    if res.is_a?(Net::HTTPSuccess)
+                      data = JSON.parse(res.body)
+                      run = data["workflow_runs"]&.first
+                      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
+                        details = [st, con].compact.join("/")
+                        status_q << [c, f, "#{emoji} (#{details})"]
+                        break if st == "completed"
+                      else
+                        status_q << [c, f, "none"]
+                        break
+                      end
+                    else
+                      status_q << [c, f, "fail #{res.code}"]
+                    end
+                  rescue Exception
+                    # Catch all exceptions to prevent crashing the process from a worker thread
+                    status_q << [c, f, "err"]
+                  end
+                  sleep(poll_interval)
+                end
+              rescue Exception
+                # Catch all exceptions in the worker thread boundary, including SystemExit
+                status_q << [c, f, "err"]
+              end
+            end
+          end
+
+          statuses = Hash.new(placeholder)
+
+          loop do
+            if selected
+              break
+            end
+
+            begin
+              code, file_name, display = status_q.pop(true)
+              statuses[code] = display
+
+              if tty
+                idx = idx_by_code[code]
+                if idx.nil?
+                  puts "status #{code}: #{display}"
+                  print(prompt)
+                else
+                  move_up = options_with_quit.size - idx + 1
+                  $stdout.print("\e[#{move_up}A\r\e[2K")
+                  disp = (code == quit_code) ? code : display_code_for[code]
+                  $stdout.print(format("%2d) %-3s => %-20s %s\n", idx + 1, disp, file_name, display))
+                  $stdout.print("\e[#{move_up - 1}B\r")
+                  $stdout.print(prompt)
+                end
+                $stdout.flush
+              else
+                puts "status #{code}: #{display}"
+              end
+            rescue ThreadError
+              sleep(0.05)
+            end
+          end
+
+          begin
+            workers.each { |t| t.kill if t&.alive? }
+          rescue StandardError
+          end
+          begin
+            input_thread.kill if input_thread&.alive?
+          rescue StandardError
+          end
+
+          input = selected
+          abort("ci:act aborted: no selection") if input.nil? || input.empty?
+
+          chosen_file = nil
+          if !!(/^\d+$/ =~ input)
+            idx = input.to_i - 1
+            if idx < 0 || idx >= options_with_quit.length
+              abort("ci:act aborted: invalid selection #{input}")
+            end
+            code, val = options_with_quit[idx]
+            if code == quit_code
+              puts "ci:act: quit"
+              return
+            else
+              chosen_file = val
+            end
+          else
+            code = input
+            if ["q", "quit", "exit"].include?(code.downcase)
+              puts "ci:act: quit"
+              return
+            end
+            chosen_file = mapping[code]
+            abort("ci:act aborted: unknown code '#{code}'") unless chosen_file
+          end
+
+          file_path = File.join(workflows_dir, chosen_file)
+          abort("ci:act aborted: workflow not found: #{file_path}") unless File.file?(file_path)
+          fetch_and_print_status.call(chosen_file)
+          run_act_for.call(file_path)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,298 @@
+# frozen_string_literal: true
+
+require "kettle/dev/exit_adapter"
+
+module Kettle
+  module Dev
+    module Tasks
+      module InstallTask
+        module_function
+
+        # Abort wrapper that avoids terminating the entire process during specs
+        def task_abort(msg)
+          if defined?(RSpec)
+            raise Kettle::Dev::Error, msg
+          else
+            Kettle::Dev::ExitAdapter.abort(msg)
+          end
+        end
+
+        def run
+          helpers = Kettle::Dev::TemplateHelpers
+          project_root = helpers.project_root
+
+          # Run file templating via dedicated task first
+          Rake::Task["kettle:dev:template"].invoke
+
+          # .tool-versions cleanup offers
+          tool_versions_path = File.join(project_root, ".tool-versions")
+          if File.file?(tool_versions_path)
+            rv = File.join(project_root, ".ruby-version")
+            rg = File.join(project_root, ".ruby-gemset")
+            to_remove = [rv, rg].select { |p| File.exist?(p) }
+            unless to_remove.empty?
+              if helpers.ask("Remove #{to_remove.map { |p| File.basename(p) }.join(" and ")} (managed by .tool-versions)?", true)
+                to_remove.each { |p| FileUtils.rm_f(p) }
+                puts "Removed #{to_remove.map { |p| File.basename(p) }.join(" and ")}"
+              end
+            end
+          end
+
+          puts
+          puts "Next steps:"
+          puts "1) Configure a shared git hooks path (optional, recommended):"
+          puts "   git config --global core.hooksPath .git-hooks"
+          puts
+          puts "2) Install binstubs for this gem so the commit-msg tool is available in ./bin:"
+          puts "   bundle binstubs kettle-dev --path bin"
+          puts "   # After running, you should have bin/kettle-commit-msg (wrapper)."
+          puts
+          # Step 3: direnv and .envrc
+          envrc_path = File.join(project_root, ".envrc")
+          puts "3) Install direnv (if not already):"
+          puts "   brew install direnv"
+          if helpers.modified_by_template?(envrc_path)
+            puts "   Your .envrc was created/updated by kettle:dev:template."
+            puts "   It includes PATH_add bin so that executables in ./bin are on PATH when direnv is active."
+            puts "   This allows running tools without the bin/ prefix inside the project directory."
+          else
+            begin
+              current = File.file?(envrc_path) ? File.read(envrc_path) : ""
+            rescue StandardError
+              current = ""
+            end
+            has_path_add = current.lines.any? { |l| l.strip =~ /^PATH_add\s+bin\b/ }
+            if has_path_add
+              puts "   Your .envrc already contains PATH_add bin."
+            else
+              puts "   Adding PATH_add bin to your project's .envrc is recommended to expose ./bin on PATH."
+              if helpers.ask("Add PATH_add bin to #{envrc_path}?", false)
+                content = current.dup
+                insertion = "# Run any command in this project's bin/ without the bin/ prefix\nPATH_add bin\n"
+                if content.empty?
+                  content = insertion
+                else
+                  content = insertion + "\n" + content unless content.start_with?(insertion)
+                end
+                # Ensure a stale directory at .envrc is removed so the file can be written
+                FileUtils.rm_rf(envrc_path) if File.directory?(envrc_path)
+                File.open(envrc_path, "w") { |f| f.write(content) }
+                puts "   Updated #{envrc_path} with PATH_add bin"
+                updated_envrc_by_install = true
+              else
+                puts "   Skipping modification of .envrc. You may add 'PATH_add bin' manually at the top."
+              end
+            end
+          end
+
+          # Warn about .env.local and offer to add it to .gitignore
+          puts
+          puts "WARNING: Do not commit .env.local; it often contains machine-local secrets."
+          puts "Ensure your .gitignore includes:"
+          puts "  # direnv - brew install direnv"
+          puts "  .env.local"
+
+          gitignore_path = File.join(project_root, ".gitignore")
+          unless helpers.modified_by_template?(gitignore_path)
+            begin
+              gitignore_current = File.exist?(gitignore_path) ? File.read(gitignore_path) : ""
+            rescue StandardError
+              gitignore_current = ""
+            end
+            has_env_local = gitignore_current.lines.any? { |l| l.strip == ".env.local" }
+            unless has_env_local
+              puts
+              puts "Would you like to add '.env.local' to #{gitignore_path}?"
+              print("Add to .gitignore now [Y/n]: ")
+              answer = $stdin.gets&.strip
+              add_it = if ENV.fetch("force", "").to_s =~ /\A(1|true|y|yes)\z/i
+                true
+              else
+                answer.nil? || answer.empty? || answer =~ /\Ay(es)?\z/i
+              end
+              if add_it
+                FileUtils.mkdir_p(File.dirname(gitignore_path))
+                mode = File.exist?(gitignore_path) ? "a" : "w"
+                File.open(gitignore_path, mode) do |f|
+                  f.write("\n") unless gitignore_current.empty? || gitignore_current.end_with?("\n")
+                  unless gitignore_current.lines.any? { |l| l.strip == "# direnv - brew install direnv" }
+                    f.write("# direnv - brew install direnv\n")
+                  end
+                  f.write(".env.local\n")
+                end
+                puts "Added .env.local to #{gitignore_path}"
+              else
+                puts "Skipping modification of .gitignore. Remember to add .env.local to avoid committing it."
+              end
+            end
+          end
+
+          # Validate gemspec homepage points to GitHub and is a non-interpolated string
+          begin
+            gemspecs = Dir.glob(File.join(project_root, "*.gemspec"))
+            if gemspecs.empty?
+              puts
+              puts "No .gemspec found in #{project_root}; skipping homepage check."
+            else
+              gemspec_path = gemspecs.first
+              if gemspecs.size > 1
+                puts
+                puts "Multiple gemspecs found; defaulting to #{File.basename(gemspec_path)} for homepage check."
+              end
+
+              content = File.read(gemspec_path)
+              homepage_line = content.lines.find { |l| l =~ /\bspec\.homepage\s*=\s*/ }
+              if homepage_line.nil?
+                puts
+                puts "WARNING: spec.homepage not found in #{File.basename(gemspec_path)}."
+                puts "This gem should declare a GitHub homepage: https://github.com/<org>/<repo>"
+              else
+                assigned = homepage_line.split("=", 2).last.to_s.strip
+                interpolated = assigned.include?('#{')
+
+                if assigned.start_with?("\"", "'")
+                  begin
+                    assigned = assigned[1..-2]
+                  rescue
+                    # leave as-is
+                  end
+                end
+
+                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
+                      v[1..-2]
+                    rescue
+                      v
+                    end
+                  end
+                  return false unless v =~ %r{\Ahttps?://github\.com/}i
+                  !!github_repo_from_url.call(v)
+                end
+
+                valid_literal = github_homepage_literal.call(assigned)
+
+                if interpolated || !valid_literal
+                  puts
+                  puts "Checking git remote 'origin' to derive GitHub homepage..."
+                  origin_url = nil
+                  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 = ""
+                  end
+
+                  org_repo = github_repo_from_url.call(origin_url)
+                  unless org_repo
+                    puts "ERROR: git remote 'origin' is not a GitHub URL (or not found): #{origin_url.empty? ? "(none)" : origin_url}"
+                    puts "To complete installation: set your GitHub repository as the 'origin' remote, and move any other forge to an alternate name."
+                    puts "Example:"
+                    puts "  git remote rename origin something_else"
+                    puts "  git remote add origin https://github.com/<org>/<repo>.git"
+                    puts "After fixing, re-run: rake kettle:dev:install"
+                    task_abort("Aborting: homepage cannot be corrected without a GitHub origin remote.")
+                  end
+
+                  org, repo = org_repo
+                  suggested = "https://github.com/#{org}/#{repo}"
+
+                  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 = $stdin.gets&.strip
+                  do_update = if ENV.fetch("force", "").to_s =~ /\A(1|true|y|yes)\z/i
+                    true
+                  else
+                    ans.nil? || ans.empty? || ans =~ /\Ay(es)?\z/i
+                  end
+
+                  if do_update
+                    new_line = homepage_line.sub(/=.*/, "= \"#{suggested}\"\n")
+                    new_content = content.sub(homepage_line, new_line)
+                    File.open(gemspec_path, "w") { |f| f.write(new_content) }
+                    puts "Updated spec.homepage in #{File.basename(gemspec_path)} to #{suggested}"
+                  else
+                    puts "Skipping update of spec.homepage. You should set it to: #{suggested}"
+                  end
+                end
+              end
+            end
+          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
+
+          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
+            if allowed_truthy || force_truthy
+              reason = allowed_truthy ? "allowed=true" : "force=true"
+              puts "Proceeding after .envrc update because #{reason}."
+            else
+              puts
+              puts "IMPORTANT: .envrc was updated during kettle:dev:install."
+              puts "Please review it and then run:"
+              puts "  direnv allow"
+              puts
+              puts "After that, re-run to resume:"
+              puts "  bundle exec rake kettle:dev:install allowed=true"
+              task_abort("Aborting: direnv allow required after .envrc changes.")
+            end
+          end
+
+          # Summary of templating changes
+          begin
+            results = helpers.template_results
+            meaningful = results.select { |_, rec| [:create, :replace, :dir_create, :dir_replace].include?(rec[:action]) }
+            puts
+            puts "Summary of templating changes:"
+            if meaningful.empty?
+              puts "  (no files were created or replaced by kettle:dev:template)"
+            else
+              action_labels = {
+                create: "Created",
+                replace: "Replaced",
+                dir_create: "Directory created",
+                dir_replace: "Directory replaced",
+              }
+              [: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
+                    abs.start_with?(project_root.to_s) ? abs.sub(/^#{Regexp.escape(project_root.to_s)}\/?/, "") : abs
+                  rescue
+                    abs
+                  end
+                  puts "    - #{rel}"
+                end
+              end
+            end
+          rescue StandardError => e
+            puts
+            puts "Summary of templating changes: (unavailable: #{e.class}: #{e.message})"
+          end
+
+          puts
+          puts "kettle:dev:install complete."
+        end
+      end
+    end
+  end
+end