legionio 1.6.2 → 1.6.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 49e219b9a9c790b6ec63903daee3a26194a5a1611cccd0013a05bb7a34a3d7c9
-  data.tar.gz: eedbb6e81c2ba386cee0718eb3aed307a021d25959579bb2a02c8bd011ca4fa5
+  metadata.gz: 72cd45444eead02f6fe56c876cc25c42c4f74111beaf76e5d898cbe94dbf2ea6
+  data.tar.gz: f9f69b056a77e373eff39813f96f79882509dfdf7273bc81afee92dc556d84f6
 SHA512:
-  metadata.gz: 141f1ad15ae3595a411e4e1ddaf7fa4544bd1fd5aa23be7425574e783a55581773d0a860ace1d7f6dce97bf3004b6fc42998374cdfe8b3555b01547e98be5f1e
-  data.tar.gz: a05b2f2cb76d9237dc785b396af6f72b03657866ba4f57fd9b7673594d3212634e9c920d90529c5134544cbdb8d32e9994b188e155366f6f69f7df803355dc90
+  metadata.gz: e86e061031320558c96fddc8bfabf2380a97cd51ee27a87d61cd7758e7cb432f8dc2b45257447146ad93ba16f4fd7100de3a90b2f3ecb95d41535a08efaf53af
+  data.tar.gz: 40420f889daf45ddf2f75533e981063b33501423ae330e59114b40dfff899e345c1deeb82c9244183842c78a952b9ad1a39d9b10ad54056afd3a7f7b3a59f0ec

data/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Legion Changelog
 
+## [1.6.3] - 2026-03-26
+
+### Changed
+- `legionio update` now uses `gem outdated` instead of custom HTTP client to check rubygems.org
+- Remove `concurrent-ruby`, `net/http`, `json` dependencies from update command
+- 4 persistent keep-alive connections replaced by single `gem outdated` call (~8s, 100% reliable)
+
 ## [1.6.2] - 2026-03-26
 
 ### Fixed

data/lib/legion/cli/update_command.rb

@@ -3,9 +3,6 @@
 require 'English'
 require 'thor'
 require 'rbconfig'
-require 'concurrent'
-require 'net/http'
-require 'json'
 require 'rubygems/uninstaller'
 
 module Legion
@@ -81,83 +78,60 @@ module Legion
 
         def update_gems(gem_names, gem_bin, dry_run: false)
           local_versions = snapshot_versions(gem_names)
-          remote_versions = fetch_remote_versions_parallel(gem_names)
+          outdated_map = fetch_outdated(gem_bin, gem_names)
 
-          outdated = gem_names.select do |name|
-            remote = remote_versions[name]
-            local = local_versions[name]
-            remote && local && Gem::Version.new(remote) > Gem::Version.new(local)
+          results = gem_names.map do |name|
+            info = outdated_map[name]
+            if info
+              { name: name, from: local_versions[name], to: info[:remote], status: dry_run ? 'available' : 'pending' }
+            else
+              { name: name, from: local_versions[name], status: 'current' }
+            end
           end
 
-          return dry_run_results(gem_names, local_versions, remote_versions, outdated) if dry_run
+          return results if dry_run
 
-          return current_results(gem_names, remote_versions) if outdated.empty?
+          pending = results.select { |r| r[:status] == 'pending' }
+          return results.each { |r| r[:status] = 'current' if r[:status] == 'pending' } if pending.empty?
 
-          install_results(gem_names, gem_bin, remote_versions, outdated)
+          install_outdated(gem_bin, pending, results)
         end
 
-        def dry_run_results(gem_names, local_versions, remote_versions, outdated)
-          gem_names.map do |name|
-            remote = remote_versions[name]
-            status = if outdated.include?(name) then 'available'
-                     elsif remote then 'current'
-                     else 'check_failed'
-                     end
-            { name: name, from: local_versions[name], to: remote, status: status }
-          end
-        end
+        def fetch_outdated(gem_bin, gem_names)
+          output = `#{gem_bin} outdated 2>&1`
+          return {} unless $CHILD_STATUS.success?
 
-        def current_results(gem_names, remote_versions)
-          gem_names.map do |name|
-            { name: name, status: remote_versions[name] ? 'current' : 'check_failed', remote: remote_versions[name] }
-          end
+          parse_outdated(output, gem_names)
         end
 
-        def install_results(gem_names, gem_bin, remote_versions, outdated)
-          output = `#{gem_bin} install #{outdated.join(' ')} --no-document 2>&1`
-          success = $CHILD_STATUS.success?
-          gem_names.map do |name|
-            if outdated.include?(name)
-              { name: name, status: success ? 'installed' : 'failed', remote: remote_versions[name], output: output.strip }
-            else
-              { name: name, status: remote_versions[name] ? 'current' : 'check_failed', remote: remote_versions[name] }
-            end
-          end
-        end
+        def parse_outdated(output, gem_names)
+          allowed = gem_names.to_set
+          output.each_line.with_object({}) do |line, map|
+            match = line.match(/^(\S+) \((\S+) < (\S+)\)/)
+            next unless match && allowed.include?(match[1])
 
-        def fetch_remote_versions_parallel(gem_names)
-          results = Concurrent::Hash.new
-          thread_count = [gem_names.size, 4].min
-          slices = gem_names.each_slice((gem_names.size / thread_count.to_f).ceil).to_a
-          threads = slices.map do |batch|
-            Thread.new(batch) do |names|
-              fetch_batch(names, results)
-            end
+            map[match[1]] = { local: match[2], remote: match[3] }
           end
-          threads.each { |t| t.join(60) }
-          results
         end
 
-        def fetch_batch(names, results)
-          Net::HTTP.start('rubygems.org', 443, use_ssl: true, open_timeout: 10, read_timeout: 10) do |http|
-            names.each do |name|
-              response = http.request(Net::HTTP::Get.new("/api/v1/versions/#{name}/latest.json"))
-              next unless response.is_a?(Net::HTTPSuccess)
-
-              data = ::JSON.parse(response.body)
-              results[name] = data['version'] if data['version']
-            rescue StandardError => e
-              Legion::Logging.debug("UpdateCommand#fetch_batch #{name}: #{e.message}") if defined?(Legion::Logging)
-            end
+        def install_outdated(gem_bin, pending, results)
+          names = pending.map { |r| r[:name] }
+          `#{gem_bin} install #{names.join(' ')} --no-document 2>&1`
+          success = $CHILD_STATUS.success?
+          pending_set = names.to_set
+          results.each do |r|
+            r[:status] = if pending_set.include?(r[:name])
+                           success ? 'installed' : 'failed'
+                         else
+                           'current'
+                         end
           end
-        rescue StandardError => e
-          Legion::Logging.debug("UpdateCommand#fetch_batch connection: #{e.message}") if defined?(Legion::Logging)
+          results
         end
 
         def display_results(out, results, before, after)
           updated = []
           failed = []
-          check_failures = 0
 
           results.each do |r|
             name = r[:name]
@@ -166,11 +140,7 @@ module Legion
               puts "  #{name}: #{r[:from]} -> #{r[:to]}"
               updated << name
             when 'current'
-              local = r[:from] || before[name]
-              puts "  #{name}: #{local || '?'} (already latest)"
-            when 'check_failed'
-              puts "  #{name}: #{before[name]} (remote check failed)"
-              check_failures += 1
+              puts "  #{name}: #{r[:from] || before[name] || '?'} (already latest)"
             when 'installed'
               old_v = before[name]
               new_v = after[name]
@@ -190,8 +160,6 @@ module Legion
           out.spacer
           if updated.any?
             out.success("Updated #{updated.size} gem(s)")
-          elsif check_failures.positive?
-            puts "#{check_failures} gem(s) could not be checked - retry or use --dry-run for details"
           else
             puts 'All gems are up to date'
           end

data/lib/legion/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Legion
-  VERSION = '1.6.2'
+  VERSION = '1.6.3'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: legionio
 version: !ruby/object:Gem::Version
-  version: 1.6.2
+  version: 1.6.3
 platform: ruby
 authors:
 - Esity