gemchain 0.2.2 → 0.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7f57089a36952e2778e0ca90654ee97a6484ba1f6f9c002a91c1a30089c6973a
-  data.tar.gz: cd1f24b7232ba48c8f1135d8e80374eb656e49e3322d3773b1f3680020761160
+  metadata.gz: 28efcb002b8ff78a3dad0554ff43dd7082221c42a927d0f61fd31d892fff87c1
+  data.tar.gz: 8e2f0892d8018723ce6f90c27abdd877249889b1f2bc357de0c9811083bf5fe5
 SHA512:
-  metadata.gz: 989b65d9e09fc06ea8445c7137b5e641fd001f7ab332023132a075c91e3a1d7b9649d34470fe78650d2c258507e5f2729d253824d85ec38b082b2efd7121e829
-  data.tar.gz: 65efa9a75881d8880d950c2b880816e10d575c9cbf728f427a0679f5fc6fc77c37f41d836a44d5359dbd412b0d8e6bf18db25772c2cae317d37b53dc58dcef1b
+  metadata.gz: 606408575bd7f7e3fd77d5b7185c37435617d8f8d728caeb42f4a42ddccd15c7570e1999ead8390703b31890720c23f886258493c79e3f066350c5a785fe98e5
+  data.tar.gz: 1afe1853d547bcf461a517b0f1216c206c84566ac1d3116aa7eefe8f72221e4d8b5e86bb82ed48bd5aba403d9652ea4204715dac90b493ccabdab3265b61e9b1

data/CHANGELOG.md

@@ -1,3 +1,24 @@
+## [0.2.4] — 2026-09-17
+
+### Fixed
+
+- **Cascade continues past dependent failures** — when a dependent fails
+  (test, build, push, etc.), its remaining steps are skipped but the
+  cascade continues to the next gem. Healthy dependents are still updated
+  and released. Previously a single failure (e.g. missing git remote)
+  halted the entire cascade, leaving perfectly good dependents untouched.
+  The final report now lists which gems failed and which succeeded.
+
+## [0.2.3] — 2026-08-13
+
+### Fixed
+
+- **Release step is idempotent for already-published versions** — a re-run
+  (or a flaky RubyGems API check during mode detection) reached `:release`
+  with the version already published and collided on `git tag`. The release
+  now checks RubyGems first (with a 5s timeout) and skips build/push/tag
+  when the version is already published.
+
 ## [0.2.2] — 2026-08-13
 
 ### Fixed

data/lib/gemchain/cascade.rb

@@ -109,13 +109,15 @@ module Gemchain
       lines.join("\n")
     end
 
-    # True when +name+ is published at +version+ on RubyGems. When rubygems
-    # is unreachable, assume not published so the full mode (bump → test →
-    # release) is preferred — bumping an already-published version is a no-op.
+    # True when +name+ is published at +version+ on RubyGems. Bounded by a
+    # short timeout; when rubygems is unreachable, assume not published so
+    # the full mode (bump → test → release) is preferred — bumping an
+    # already-published version is a no-op, and the executor's release step
+    # additionally skips re-releases of published versions.
     def released_on_rubygems?(name, version)
       require "json"
       require "net/http"
-      body = Net::HTTP.get(URI("https://rubygems.org/api/v1/gems/#{name}.json"))
+      body = Timeout.timeout(5) { Net::HTTP.get(URI("https://rubygems.org/api/v1/gems/#{name}.json")) }
       JSON.parse(body)["version"] == version
     rescue StandardError
       false

data/lib/gemchain/cli.rb

@@ -120,10 +120,17 @@ module Gemchain
             puts "\n  Cascade complete."
           end
         else
-          gem, message = result.failed.first
-          puts "\n  ✖ Cascade stopped at #{gem}:"
-          puts "     #{message}"
-          puts "  Released so far: #{result.released.join(', ')}" unless result.released.empty?
+          puts "\n  ⚠️  Cascade completed with failures:"
+          result.failed.each do |gem, message|
+            puts "    ✖ #{gem}: #{message.split("\n").first}"
+          end
+          puts "\n  ✅ Released: #{result.released.join(', ')}" unless result.released.empty?
+          puts "  ⏭ Skipped: #{result.skipped.join(', ')}" unless result.skipped.empty?
+          if result.released.empty?
+            puts "\n  No gems were released."
+          else
+            puts "\n  Good dependents were updated successfully."
+          end
         end
       end
       puts

data/lib/gemchain/executor.rb

@@ -1,14 +1,18 @@
 # frozen_string_literal: true
 
 require "open3"
+require "set"
+require "timeout"
 
 module Gemchain
   class ExecutionError < Error; end
 
   # Executes a cascade plan: bumps versions, rewrites gemspec constraints,
-  # runs test suites, and releases gems to RubyGems — stopping at the first
-  # failure. All shell interaction goes through the +runner+ so the whole
-  # pipeline is testable without touching bundler, git, or RubyGems.
+  # runs test suites, and releases gems to RubyGems. On failure the
+  # remaining steps for the failing gem are skipped but the cascade
+  # continues to the next gem, so healthy dependents are still updated.
+  # All shell interaction goes through the +runner+ so the whole pipeline
+  # is testable without touching bundler, git, or RubyGems.
   class Executor
     Result = Struct.new(:success, :released, :skipped, :failed, keyword_init: true)
 
@@ -36,14 +40,17 @@ module Gemchain
 
     # @param workspace [Workspace] the gem ecosystem
     # @param steps [Array<Hash>] the plan from Cascade#update
-    # @param runner [#run] command runner (defaults to the real one)
+    # @param runner [#run, #success?] command runner (defaults to the real one)
     # @param confirm [Proc] per-release confirmation, called with a message;
     #   defaults to a [y/N] prompt on stdin
     # @param yes [Boolean] skip confirmations entirely
     # @param bump [Symbol] dependent version bump level (:patch, :minor, :major)
     # @param output [#puts] progress output stream
+    # @param released_check [Proc] (name, version) → published on RubyGems?
+    #   Used to skip releases whose version is already published; defaults
+    #   to a RubyGems API lookup with a short timeout.
     def initialize(workspace:, steps:, runner: nil, confirm: nil, yes: false,
-                   bump: :patch, output: $stdout)
+                   bump: :patch, output: $stdout, released_check: nil)
       @workspace = workspace
       @steps = steps
       @runner = runner || Runner.new
@@ -51,14 +58,23 @@ module Gemchain
       @yes = yes
       @bump = bump.to_sym
       @output = output
+      @released_check = released_check || method(:released_on_rubygems?)
       raise ArgumentError, "bump must be one of #{BUMP_LEVELS.inspect}" unless BUMP_LEVELS.include?(@bump)
     end
 
     def run
       released = []
       skipped = []
+      failed = {}
+      failed_gems = Set.new
 
       @steps.each do |step|
+        # Skip remaining steps for a gem that already failed
+        if failed_gems.include?(step[:gem])
+          @output.puts "  ⏭ Skipping remaining steps for #{step[:gem]} (previous step failed)"
+          next
+        end
+
         begin
           case step[:action]
           when :bump
@@ -77,12 +93,14 @@ module Gemchain
             end
           end
         rescue ExecutionError => e
-          return Result.new(success: false, released: released, skipped: skipped,
-                            failed: {step[:gem] => e.message})
+          @output.puts "  ✖ #{step[:gem]}: #{e.message.split("\n").first}"
+          failed[step[:gem]] = e.message
+          failed_gems << step[:gem]
         end
       end
 
-      Result.new(success: true, released: released, skipped: skipped, failed: nil)
+      success = failed.empty?
+      Result.new(success: success, released: released, skipped: skipped, failed: failed.empty? ? nil : failed)
     end
 
     private
@@ -169,6 +187,14 @@ module Gemchain
       name = step[:gem]
       version = step[:version] || bump_dependent(dir, name)
 
+      # Idempotency guard: a re-run (or flaky mode detection) can reach
+      # :release with the version already published — re-pushing/tagging
+      # would fail. Skip the release entirely in that case.
+      if @released_check.call(name, version)
+        @output.puts "  ⏭ #{name} #{version} already on RubyGems — skipping release"
+        return
+      end
+
       files = release_files(dir)
       @runner.run(["git", "add", *files], chdir: dir)
 
@@ -205,6 +231,18 @@ module Gemchain
       status.success?
     end
 
+    # True when +name+ is published at +version+ on RubyGems. Bounded by a
+    # short timeout; on any failure assume NOT published so the release
+    # proceeds (a no-op re-push is safer than silently skipping a real one).
+    def released_on_rubygems?(name, version)
+      require "json"
+      require "net/http"
+      body = Timeout.timeout(5) { Net::HTTP.get(URI("https://rubygems.org/api/v1/gems/#{name}.json")) }
+      JSON.parse(body)["version"] == version
+    rescue StandardError
+      false
+    end
+
     # Dependents get an automatic version bump (they're being re-released
     # with a tightened constraint); the source gem's version comes from the
     # :bump step.

data/lib/gemchain/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Gemchain
-  VERSION = "0.2.2"
+  VERSION = "0.2.4"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: gemchain
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.2.4
 platform: ruby
 authors:
 - Kaka Ruto