kettle-dev 1.1.4 → 1.1.5

data/lib/kettle/dev/gem_spec_reader.rb

@@ -8,23 +8,54 @@ module Kettle
     # Returns a Hash with all data used by this project from gemspecs.
     # Cache within the process to avoid repeated loads.
     class GemSpecReader
+      # Default minimum Ruby version to assume when a gemspec doesn't specify one.
+      # @return [Gem::Version]
       DEFAULT_MINIMUM_RUBY = Gem::Version.new("1.8").freeze
       class << self
-        # Load gemspec data for the project at root.
-        # @param root [String]
-        # @return [Hash]
+        # Load gemspec data for the project at root using RubyGems.
+        # The reader is lenient: failures to load or missing fields are handled with defaults and warnings.
+        #
+        # @param root [String] project root containing a *.gemspec file
+        # @return [Hash{Symbol=>Object}] a Hash of gem metadata used by templating and tasks
+        # @option return [String, nil] :gemspec_path absolute path to gemspec or nil when not found
+        # @option return [String] :gem_name gem name ("" when not derivable)
+        # @option return [Gem::Version] :min_ruby minimum Ruby version derived or DEFAULT_MINIMUM_RUBY
+        # @option return [String] :homepage homepage string (may be "")
+        # @option return [String] :gh_org GitHub org (falls back to "kettle-rb")
+        # @option return [String] :forge_org primary forge org (currently same as gh_org)
+        # @option return [String, nil] :funding_org OpenCollective/org handle or nil when not discovered
+        # @option return [String, nil] :gh_repo GitHub repo name, if discoverable
+        # @option return [String] :namespace Ruby namespace derived from gem name (e.g., "Kettle::Dev")
+        # @option return [String] :namespace_shield URL-escaped namespace for shields
+        # @option return [String] :entrypoint_require require path for gem (e.g., "kettle/dev")
+        # @option return [String] :gem_shield shield-safe gem name
+        # @option return [Array<String>] :authors
+        # @option return [Array<String>] :email
+        # @option return [String] :summary
+        # @option return [String] :description
+        # @option return [Array<String>] :licenses includes both license and licenses values
+        # @option return [Gem::Requirement, nil] :required_ruby_version
+        # @option return [Array<String>] :require_paths
+        # @option return [String] :bindir
+        # @option return [Array<String>] :executables
         def load(root)
           gemspec_path = Dir.glob(File.join(root.to_s, "*.gemspec")).first
           spec = nil
           if gemspec_path && File.file?(gemspec_path)
             begin
               spec = Gem::Specification.load(gemspec_path)
-            rescue StandardError
+            rescue StandardError => e
+              Kettle::Dev.debug_error(e, __method__)
               spec = nil
             end
           end
 
           gem_name = spec&.name.to_s
+          if gem_name.nil? || gem_name.strip.empty?
+            # Be lenient here for tasks that can proceed without gem_name (e.g., choosing destination filenames).
+            Kernel.warn("kettle-dev: Could not derive gem name. Ensure a valid <name> is set in the gemspec.\n  - Tip: set the gem name in your .gemspec file (spec.name).\n  - Path searched: #{gemspec_path || "(none found)"}")
+            gem_name = ""
+          end
           # minimum ruby version: derived from spec.required_ruby_version
           # Always an instance of Gem::Version
           min_ruby =
@@ -41,34 +72,21 @@ module Kettle
                 DEFAULT_MINIMUM_RUBY
               end
             rescue StandardError => e
+              puts "WARNING: Minimum Ruby detection failed:"
+              Kettle::Dev.debug_error(e, __method__)
               # Default to a minimum of Ruby 1.8
-              puts "WARNING: Minimum Ruby detection failed: #{e.class}: #{e.message}"
               DEFAULT_MINIMUM_RUBY
             end
 
           homepage_val = spec&.homepage.to_s
 
           # Derive org/repo from homepage or git remote
-          forge_org = nil
-          gh_repo = nil
-          if homepage_val && !homepage_val.empty?
-            if (m = homepage_val.match(%r{github\.com[/:]([^/]+)/([^/]+)}i))
-              forge_org = m[1]
-              gh_repo = m[2].to_s.sub(/\.git\z/, "")
-            end
-          end
-          if forge_org.nil?
-            begin
-              origin_out = IO.popen(["git", "-C", root.to_s, "remote", "get-url", "origin"], &:read)
-              origin_out = origin_out.read if origin_out.respond_to?(:read)
-              origin_url = origin_out.to_s.strip
-              if (m = origin_url.match(%r{github\.com[/:]([^/]+)/([^/]+)}i))
-                forge_org = m[1]
-                gh_repo = m[2].to_s.sub(/\.git\z/, "")
-              end
-            rescue StandardError
-              # ignore
-            end
+          forge_info = derive_forge_and_origin_repo(homepage_val)
+          forge_org = forge_info[:forge_org]
+          gh_repo = forge_info[:origin_repo]
+          if forge_org.to_s.empty?
+            Kernel.warn("kettle-dev: Could not determine forge org from spec.homepage or git remote.\n  - Ensure gemspec.homepage is set to a GitHub URL or that the git remote 'origin' points to GitHub.\n  - Example homepage: https://github.com/<org>/<repo>\n  - Proceeding with default org: kettle-rb.")
+            forge_org = "kettle-rb"
           end
 
           camel = lambda do |s|
@@ -79,24 +97,35 @@ module Kettle
           entrypoint_require = gem_name.to_s.tr("-", "/")
           gem_shield = gem_name.to_s.gsub("-", "--").gsub("_", "__")
 
-          # Funding org detection (ENV, .opencollective.yml, fallback to forge_org)
-          funding_org = ENV["FUNDING_ORG"].to_s.strip
-          funding_org = ENV["OPENCOLLECTIVE_ORG"].to_s.strip if funding_org.empty?
-          funding_org = ENV["OPENCOLLECTIVE_HANDLE"].to_s.strip if funding_org.empty?
-          if funding_org.empty?
-            begin
-              oc_path = File.join(root.to_s, ".opencollective.yml")
-              if File.file?(oc_path)
-                txt = File.read(oc_path)
-                if (m = txt.match(/\borg:\s*([\w\-]+)/i))
-                  funding_org = m[1].to_s
+          # Funding org detection with bypass support.
+          # By default a funding org must be discoverable, unless explicitly disabled by ENV['FUNDING_ORG'] == 'false'.
+          funding_org_env = ENV["FUNDING_ORG"]
+          funding_org = funding_org_env.to_s.strip
+          begin
+            # Handle bypass: allow explicit string 'false' (any case) to disable funding org requirement.
+            if funding_org_env && funding_org_env.to_s.strip.casecmp("false").zero?
+              funding_org = nil
+            else
+              funding_org = ENV["OPENCOLLECTIVE_HANDLE"].to_s.strip if funding_org.empty?
+              if funding_org.to_s.empty?
+                oc_path = File.join(root.to_s, ".opencollective.yml")
+                if File.file?(oc_path)
+                  txt = File.read(oc_path)
+                  if (m = txt.match(/\borg:\s*([\w\-]+)/i))
+                    funding_org = m[1].to_s
+                  end
                 end
               end
-            rescue StandardError
-              # ignore
+              # Be lenient: if funding_org cannot be determined, do not raise — leave it nil and warn.
+              if funding_org.to_s.empty?
+                Kernel.warn("kettle-dev: Could not determine funding org.\n  - Options:\n    * Set ENV['FUNDING_ORG'] to your funding handle (e.g., 'opencollective-handle').\n    * Or set ENV['OPENCOLLECTIVE_HANDLE'].\n    * Or add .opencollective.yml with: org: <handle>\n    * Or bypass by setting ENV['FUNDING_ORG']=false for gems without funding.")
+                funding_org = nil
+              end
             end
+          rescue StandardError => error
+            Kettle::Dev.debug_error(error, __method__)
+            raise Error, "Unable to determine funding org from env or .opencollective.yml.\n\tError was: #{error.class}: #{error.message}"
           end
-          funding_org = forge_org.to_s if funding_org.to_s.empty?
 
           {
             gemspec_path: gemspec_path,
@@ -123,6 +152,43 @@ module Kettle
             executables: Array(spec&.executables),
           }
         end
+
+        private
+
+        # Derive the forge organization and origin repository name using homepage or git remotes.
+        # Prefers GitHub-style URLs.
+        #
+        # @param homepage_val [String] the homepage string from the gemspec (may be empty)
+        # @return [Hash{Symbol=>String,nil}] keys: :forge_org, :origin_repo (both may be nil when not discoverable)
+        def derive_forge_and_origin_repo(homepage_val)
+          forge_info = {}
+
+          if homepage_val && !homepage_val.empty?
+            m = homepage_val.match(%r{github\.com[/:]([^/]+)/([^/]+)}i)
+
+            if m
+              forge_info[:forge_org] = m[1]
+              forge_info[:origin_repo] = m[2].to_s.sub(/\.git\z/, "")
+            end
+          end
+
+          if forge_info[:forge_org].nil? || forge_info[:forge_org].to_s.empty?
+            begin
+              ga = Kettle::Dev::GitAdapter.new
+              origin_url = ga.remote_url("origin") || ga.remotes_with_urls["origin"]
+              origin_url = origin_url.to_s.strip
+              if (m = origin_url.match(%r{github\.com[/:]([^/]+)/([^/]+)}i))
+                forge_info[:forge_org] = m[1]
+                forge_info[:origin_repo] = m[2].to_s.sub(/\.git\z/, "")
+              end
+            rescue StandardError => error
+              Kettle::Dev.debug_error(error, __method__)
+              # be lenient here; actual error raising will occur in caller if required
+            end
+          end
+
+          forge_info
+        end
       end
     end
   end

data/lib/kettle/dev/git_adapter.rb

@@ -183,7 +183,8 @@ module Kettle
         else
           system("git", "checkout", branch.to_s)
         end
-      rescue StandardError
+      rescue StandardError => e
+        Kettle::Dev.debug_error(e, __method__)
         false
       end
 
@@ -198,7 +199,8 @@ module Kettle
         else
           system("git", "pull", remote.to_s, branch.to_s)
         end
-      rescue StandardError
+      rescue StandardError => e
+        Kettle::Dev.debug_error(e, __method__)
         false
       end
 
@@ -219,7 +221,8 @@ module Kettle
         else
           system("git", "fetch", remote.to_s)
         end
-      rescue StandardError
+      rescue StandardError => e
+        Kettle::Dev.debug_error(e, __method__)
         false
       end
     end

data/lib/kettle/dev/git_commit_footer.rb

@@ -22,7 +22,9 @@ module Kettle
           begin
             out = %x(git rev-parse --show-toplevel 2>/dev/null)
             toplevel = out.strip unless out.nil? || out.empty?
-          rescue StandardError
+          rescue StandardError => e
+            Kettle::Dev.debug_error(e, __method__)
+            nil
           end
           toplevel
         end
@@ -111,7 +113,8 @@ module Kettle
           if @name_index
             return $2
           end
-        rescue StandardError
+        rescue StandardError => e
+          Kettle::Dev.debug_error(e, __method__)
         end
         nil
       end

data/lib/kettle/dev/pre_release_cli.rb

@@ -0,0 +1,248 @@
+# frozen_string_literal: true
+
+require "optparse"
+require "uri"
+require "net/http"
+require "openssl"
+begin
+  require "addressable/uri"
+rescue LoadError
+  # addressable is optional; code will fallback to URI
+end
+
+module Kettle
+  module Dev
+    # PreReleaseCLI: run pre-release checks before invoking full release workflow.
+    # Checks:
+    #   1) Normalize Markdown image URLs using Addressable normalization.
+    #   2) Validate Markdown image links resolve via HTTP(S) HEAD.
+    #
+    # Usage: Kettle::Dev::PreReleaseCLI.new(check_num: 1).run
+    class PreReleaseCLI
+      # Simple HTTP helpers for link validation
+      module HTTP
+        module_function
+
+        # Unicode-friendly HTTP URI parser with Addressable fallback.
+        # @param url_str [String]
+        # @return [URI]
+        def parse_http_uri(url_str)
+          if defined?(Addressable::URI)
+            addr = Addressable::URI.parse(url_str)
+            # Build a standard URI with properly encoded host/path/query for Net::HTTP
+            # Addressable handles unicode and punycode automatically via normalization
+            addr = addr.normalize
+            # Net::HTTP expects a ::URI; convert via to_s then URI.parse
+            URI.parse(addr.to_s)
+          else
+            # Fallback: try URI.parse directly; users can add addressable to unlock unicode support
+            URI.parse(url_str)
+          end
+        end
+
+        # Perform HTTP HEAD against the given url.
+        # Falls back to GET when HEAD is not allowed.
+        # @param url_str [String]
+        # @param limit [Integer] max redirects
+        # @param timeout [Integer] per-request timeout seconds
+        # @return [Boolean] true when successful (2xx) after following redirects
+        def head_ok?(url_str, limit: 5, timeout: 10)
+          uri = parse_http_uri(url_str)
+          raise ArgumentError, "unsupported URI scheme: #{uri.scheme.inspect}" unless %w[http https].include?(uri.scheme)
+
+          request = Net::HTTP::Head.new(uri)
+          perform(uri, request, limit: limit, timeout: timeout)
+        end
+
+        # @api private
+        def perform(uri, request, limit:, timeout:)
+          raise ArgumentError, "too many redirects" if limit <= 0
+
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.use_ssl = uri.scheme == "https"
+          http.read_timeout = timeout
+          http.open_timeout = timeout
+          http.ssl_timeout = timeout if http.respond_to?(:ssl_timeout=)
+          http.verify_mode = OpenSSL::SSL::VERIFY_PEER if http.use_ssl?
+
+          response = http.start { |h| h.request(request) }
+
+          case response
+          when Net::HTTPRedirection
+            location = response["location"]
+            return false unless location
+            new_uri = parse_http_uri(location)
+            new_uri = uri + location if new_uri.relative?
+            head_ok?(new_uri.to_s, limit: limit - 1, timeout: timeout)
+          when Net::HTTPSuccess
+            true
+          else
+            if response.is_a?(Net::HTTPMethodNotAllowed)
+              get_req = Net::HTTP::Get.new(uri)
+              get_resp = http.start { |h| h.request(get_req) }
+              return get_resp.is_a?(Net::HTTPSuccess)
+            end
+            false
+          end
+        rescue Timeout::Error, Errno::ECONNREFUSED, Errno::EHOSTUNREACH, SocketError, OpenSSL::SSL::SSLError => e
+          warn("[kettle-pre-release] HTTP error for #{uri}: #{e.class}: #{e.message}")
+          false
+        end
+      end
+
+      # Markdown parsing helpers
+      module Markdown
+        module_function
+
+        # Extract unique remote HTTP(S) image URLs from markdown or HTML images.
+        # @param text [String]
+        # @return [Array<String>]
+        def extract_image_urls_from_text(text)
+          urls = []
+
+          # Inline image syntax
+          text.scan(/!\[[^\]]*\]\(([^\s)]+)(?:\s+\"[^\"]*\")?\)/) { |m| urls << m[0] }
+
+          # Reference definitions
+          ref_defs = {}
+          text.scan(/^\s*\[([^\]]+)\]:\s*(\S+)/) { |m| ref_defs[m[0]] = m[1] }
+
+          # Reference image usage
+          text.scan(/!\[[^\]]*\]\[([^\]]+)\]/) do |m|
+            id = m[0]
+            url = ref_defs[id]
+            urls << url if url
+          end
+
+          # HTML <img src="...">
+          text.scan(/<img\b[^>]*\bsrc\s*=\s*\"([^\"]+)\"[^>]*>/i) { |m| urls << m[0] }
+          text.scan(/<img\b[^>]*\bsrc\s*=\s*\'([^\']+)\'[^>]*>/i) { |m| urls << m[0] }
+
+          urls.reject! { |u| u.nil? || u.strip.empty? }
+          urls.select! { |u| u =~ %r{^https?://}i }
+          urls.uniq
+        end
+
+        # Extract from files matching glob.
+        # @param glob_pattern [String]
+        # @return [Array<String>]
+        def extract_image_urls_from_files(glob_pattern = "*.md")
+          files = Dir.glob(glob_pattern)
+          urls = files.flat_map do |f|
+            begin
+              extract_image_urls_from_text(File.read(f))
+            rescue StandardError => e
+              warn("[kettle-pre-release] Could not read #{f}: #{e.class}: #{e.message}")
+              []
+            end
+          end
+          urls.uniq
+        end
+      end
+
+      # @param check_num [Integer] 1-based index to resume from
+      def initialize(check_num: 1)
+        @check_num = (check_num || 1).to_i
+        @check_num = 1 if @check_num < 1
+      end
+
+      # Execute configured checks starting from @check_num.
+      # @return [void]
+      def run
+        checks = []
+        checks << method(:check_markdown_uri_normalization!)
+        checks << method(:check_markdown_images_http!)
+
+        start = @check_num
+        raise ArgumentError, "check_num must be >= 1" if start < 1
+        begin_idx = start - 1
+        checks[begin_idx..-1].each_with_index do |check, i|
+          idx = begin_idx + i + 1
+          puts "[kettle-pre-release] Running check ##{idx} of #{checks.size}"
+          check.call
+        end
+        nil
+      end
+
+      # Check 1: Normalize Markdown image URLs
+      #   Compares URLs to Addressable-normalized form and rewrites Markdown when needed.
+      # @return [void]
+      def check_markdown_uri_normalization!
+        puts "[kettle-pre-release] Check 1: Normalize Markdown image URLs"
+        files = Dir.glob(["**/*.md", "**/*.md.example"])
+        changed = []
+        total_candidates = 0
+
+        files.each do |file|
+          begin
+            original = File.read(file)
+          rescue StandardError => e
+            warn("[kettle-pre-release] Could not read #{file}: #{e.class}: #{e.message}")
+            next
+          end
+
+          text = original.dup
+          urls = Markdown.extract_image_urls_from_text(text)
+          next if urls.empty?
+
+          total_candidates += urls.size
+          updated = text.dup
+          modified = false
+
+          urls.each do |url_str|
+            addr = Addressable::URI.parse(url_str)
+            normalized = addr.normalize.to_s
+            next if normalized == url_str
+
+            # Replace exact occurrences of the URL in the markdown content
+            updated.gsub!(url_str, normalized)
+            modified = true
+            puts "  -> #{file}: normalized #{url_str} -> #{normalized}"
+          end
+
+          if modified && updated != original
+            begin
+              File.write(file, updated)
+              changed << file
+            rescue StandardError => e
+              warn("[kettle-pre-release] Could not write #{file}: #{e.class}: #{e.message}")
+            end
+          end
+        end
+
+        puts "[kettle-pre-release] Normalization candidates: #{total_candidates}. Files changed: #{changed.uniq.size}."
+        nil
+      end
+
+      # Check 2: Validate Markdown image links by HTTP HEAD (no rescue for parse failures)
+      # @return [void]
+      def check_markdown_images_http!
+        puts "[kettle-pre-release] Check 2: Validate Markdown image links (HTTP HEAD)"
+        urls = [
+          Markdown.extract_image_urls_from_files("**/*.md"),
+          Markdown.extract_image_urls_from_files("**/*.md.example"),
+        ].flatten.uniq
+        puts "[kettle-pre-release] Found #{urls.size} unique image URL(s)."
+        failures = []
+        urls.each do |url|
+          print("  -> #{url} … ")
+          ok = HTTP.head_ok?(url)
+          if ok
+            puts "OK"
+          else
+            puts "FAIL"
+            failures << url
+          end
+        end
+        if failures.any?
+          warn("[kettle-pre-release] #{failures.size} image URL(s) failed validation:")
+          failures.each { |u| warn("  - #{u}") }
+          Kettle::Dev::ExitAdapter.abort("Image link validation failed")
+        else
+          puts "[kettle-pre-release] All image links validated."
+        end
+        nil
+      end
+    end
+  end
+end

data/lib/kettle/dev/readme_backers.rb

@@ -127,7 +127,8 @@ module Kettle
               from_yml = from_yml.to_s if from_yml
               return from_yml unless from_yml.nil? || from_yml.strip.empty?
             end
-          rescue StandardError
+          rescue StandardError => e
+            Kettle::Dev.debug_error(e, __method__)
           end
         end
         README_OSC_TAG_DEFAULT
@@ -321,7 +322,8 @@ module Kettle
               from_yml = from_yml.to_s if from_yml
               return from_yml unless from_yml.nil? || from_yml.strip.empty?
             end
-          rescue StandardError
+          rescue StandardError => e
+            Kettle::Dev.debug_error(e, __method__)
           end
         end
         COMMIT_SUBJECT_DEFAULT

data/lib/kettle/dev/release_cli.rb

@@ -16,6 +16,21 @@ require "ruby-progressbar"
 module Kettle
   module Dev
     class ReleaseCLI
+      class << self
+        def run_cmd!(cmd)
+          # For Bundler-invoked build/release, explicitly prefix SKIP_GEM_SIGNING so
+          # the signing step is skipped even when Bundler scrubs ENV.
+          if ENV["SKIP_GEM_SIGNING"] && cmd =~ /\Abundle(\s+exec)?\s+rake\s+(build|release)\b/
+            cmd = "SKIP_GEM_SIGNING=true #{cmd}"
+          end
+          puts "$ #{cmd}"
+          # Pass a plain Hash for the environment to satisfy tests and avoid ENV object oddities
+          env_hash = ENV.respond_to?(:to_hash) ? ENV.to_hash : ENV.to_h
+          success = system(env_hash, cmd)
+          abort("Command failed: #{cmd}") unless success
+        end
+      end
+
       private
 
       def abort(msg)
@@ -243,7 +258,8 @@ module Kettle
           version ||= detect_version
           gem_name = detect_gem_name
           puts "\n🚀 Release #{gem_name} v#{version} Complete 🚀"
-        rescue StandardError
+        rescue StandardError => e
+          Kettle::Dev.debug_error(e, __method__)
           # Fallback if detection fails for any reason
           puts "\n🚀 Release v#{version || "unknown"} Complete 🚀"
         end
@@ -455,21 +471,12 @@ module Kettle
       end
 
       def monitor_workflows_after_push!
-        # Delegate to shared CI monitor to keep logic DRY across release flow and rake tasks
+        # Use abort-on-failure CI monitor to match historical behavior and specs
         Kettle::Dev::CIMonitor.monitor_all!(restart_hint: "bundle exec kettle-release start_step=10")
       end
 
       def run_cmd!(cmd)
-        # For Bundler-invoked build/release, explicitly prefix SKIP_GEM_SIGNING so
-        # the signing step is skipped even when Bundler scrubs ENV.
-        if ENV["SKIP_GEM_SIGNING"] && cmd =~ /\Abundle(\s+exec)?\s+rake\s+(build|release)\b/
-          cmd = "SKIP_GEM_SIGNING=true #{cmd}"
-        end
-        puts "$ #{cmd}"
-        # Pass a plain Hash for the environment to satisfy tests and avoid ENV object oddities
-        env_hash = ENV.respond_to?(:to_hash) ? ENV.to_hash : ENV.to_h
-        success = system(env_hash, cmd)
-        abort("Command failed: #{cmd}") unless success
+        self.class.run_cmd!(cmd)
       end
 
       def git_output(args)
@@ -479,15 +486,16 @@ module Kettle
       end
 
       def ensure_git_user!
-        name, ok1 = git_output(["config", "user.name"])
-        email, ok2 = git_output(["config", "user.email"])
+        name, ok1 = git_output(%w[config user.name])
+        email, ok2 = git_output(%w[config user.email])
         abort("Git user.name or user.email not configured.") unless ok1 && ok2 && !name.empty? && !email.empty?
       end
 
       def ensure_bundler_2_7_plus!
         begin
           require "bundler"
-        rescue LoadError
+        rescue LoadError => e
+          Kettle::Dev.debug_error(e, __method__)
           abort("Bundler is required. Please install bundler >= 2.7.0 and try again.")
         end
         ver = Gem::Version.new(Bundler::VERSION)
@@ -512,7 +520,8 @@ module Kettle
 
         act_ok = begin
           system("act", "--version", out: File::NULL, err: File::NULL)
-        rescue StandardError
+        rescue StandardError => e
+          Kettle::Dev.debug_error(e, __method__)
           false
         end
         unless act_ok
@@ -592,7 +601,8 @@ module Kettle
         series_versions = gversions.select { |gv| gv.segments[0, 2] == series }
         latest_series = series_versions.last&.to_s
         [latest_overall, latest_series]
-      rescue StandardError
+      rescue StandardError => e
+        Kettle::Dev.debug_error(e, __method__)
         [nil, nil]
       end