libyear-bundler 0.8.0 → 0.9.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6e363af1df56aed65c6977f010e31514cc9e57e3b4270eacecff7005033554a3
-  data.tar.gz: 9293a7bc0a6708685577e28d85f43efeb15c3031f5432277be2fc593391a2d62
+  metadata.gz: '0598b786c916a1f5645f5785f9e71b7dee517a908abd24410ebd5c9262e1681a'
+  data.tar.gz: 78396f8f657749c1206f76b7ab7d47a1ed6f182f9aefcba0ed478dfa72b3a83d
 SHA512:
-  metadata.gz: 4bed9a52de479d8a0479846cfa26beaf71b48c4df930a2e1bd86a021fabbb3b755e33148e6d2fcda14ab6297d304ade51331f38074d6e7a45ddab7f476ee0cb7
-  data.tar.gz: d190eb7367ccc794de8ba33ecf5794cb86b431a8b9227975d28c93f08f9930c1fd92e555e2280f720b9153647308a57694c2163a1599d43449b212e6ed56448c
+  metadata.gz: 8a9c45f47f10127b72ee0bfc4a38d52e3fff677b55d93d8f125730b5a3bf1f9a8920590667465af4388ad14cbeda33c37852a51729497a0740d003b326057797
+  data.tar.gz: 38610ebd31b56aa6173b2ff861756fa602bbefe63855de0ec4d21d2940e0292278ae3f82ad2ff08633813ffce7c890b88a8a20341962f54b3354f5c4e599c03c

data/lib/libyear_bundler/bundle_outdated.rb

@@ -17,21 +17,25 @@ module LibyearBundler
     end
 
     def execute
-      bundle_outdated.lines.each_with_object([]) do |line, gems|
-        match = BOP_FMT.match(line)
-        next if match.nil?
-        if malformed_version_strings?(match)
-          warn "Skipping #{match['name']} because of a malformed version string"
-          next
-        end
+      uri = URI('https://rubygems.org')
+      Net::HTTP.start(uri.host, uri.port, use_ssl: true) do |http|
+        bundle_outdated.lines.each_with_object([]) do |line, gems|
+          match = BOP_FMT.match(line)
+          next if match.nil?
+          if malformed_version_strings?(match)
+            warn "Skipping #{match['name']} because of a malformed version string"
+            next
+          end
 
-        gem = ::LibyearBundler::Models::Gem.new(
-          match['name'],
-          match['installed'],
-          match['newest'],
-          @release_date_cache
-        )
-        gems.push(gem)
+          gem = ::LibyearBundler::Models::Gem.new(
+            match['name'],
+            match['installed'],
+            match['newest'],
+            @release_date_cache,
+            http
+          )
+          gems.push(gem)
+        end
       end
     end
 

data/lib/libyear_bundler/cli.rb

@@ -3,7 +3,8 @@ require "bundler/cli/outdated"
 require "libyear_bundler/bundle_outdated"
 require "libyear_bundler/options"
 require "libyear_bundler/release_date_cache"
-require "libyear_bundler/report"
+require "libyear_bundler/reports/console"
+require "libyear_bundler/reports/json"
 require 'libyear_bundler/models/ruby'
 
 module LibyearBundler
@@ -73,7 +74,10 @@ module LibyearBundler
     end
 
     def report
-      @_report ||= Report.new(bundle_outdated, ruby, @options, $stdout)
+      @_report ||= begin
+        reporter_class = @options.json? ? Reports::JSON : Reports::Console
+        reporter_class.new(bundle_outdated, ruby, @options, $stdout)
+      end
     end
 
     def ruby

data/lib/libyear_bundler/models/gem.rb

@@ -7,7 +7,7 @@ module LibyearBundler
     # Logic and information pertaining to the installed and newest versions of
     # a gem
     class Gem
-      def initialize(name, installed_version, newest_version, release_date_cache)
+      def initialize(name, installed_version, newest_version, release_date_cache, http)
         unless release_date_cache.nil? || release_date_cache.is_a?(ReleaseDateCache)
           raise TypeError, 'Invalid release_date_cache'
         end
@@ -15,29 +15,28 @@ module LibyearBundler
         @installed_version = installed_version
         @newest_version = newest_version
         @release_date_cache = release_date_cache
+        @http = http
       end
 
       class << self
-        def release_date(gem_name, gem_version)
-          dep = nil
-          begin
-            dep = ::Bundler::Dependency.new(gem_name, gem_version)
-          rescue ::Gem::Requirement::BadRequirementError => e
-            report_problem(gem_name, <<-MSG)
-Could not find release date for: #{gem_name}
-#{e}
-Maybe you used git in your Gemfile, which libyear doesn't support yet. Contributions welcome.
-            MSG
-            return nil
+        def release_date(gem_name, gem_version, http)
+          uri = URI.parse(
+            "https://rubygems.org/api/v2/rubygems/#{gem_name}/versions/#{gem_version}.json"
+          )
+          request = Net::HTTP::Get.new(uri)
+          response = http.request(request)
+          if response.is_a?(Net::HTTPSuccess)
+            parsed_response = JSON.parse(response.body)
+            Date.parse(parsed_response["version_created_at"])
+          else
+            report_problem(
+              gem_name,
+              "Release date not found: #{gem_name}: rubygems.org responded with #{response.code}"
+            )
+            nil
           end
-          tuples, _errors = ::Gem::SpecFetcher.fetcher.search_for_dependency(dep)
-          if tuples.empty?
-            report_problem(gem_name, "Could not find release date for: #{gem_name}")
-            return nil
-          end
-          tup, source = tuples.first # Gem::NameTuple
-          spec = source.fetch_spec(tup) # raises Gem::RemoteFetcher::FetchError
-          spec.date.to_date
+        rescue StandardError => e
+          report_problem(gem_name, "Release date not found: #{gem_name}: #{e.inspect}")
         end
 
         private
@@ -57,7 +56,7 @@ Maybe you used git in your Gemfile, which libyear doesn't support yet. Contribut
 
       def installed_version_release_date
         if @release_date_cache.nil?
-          self.class.release_date(name, installed_version)
+          self.class.release_date(name, installed_version, @http)
         else
           @release_date_cache[name, installed_version]
         end
@@ -88,7 +87,7 @@ Maybe you used git in your Gemfile, which libyear doesn't support yet. Contribut
 
       def newest_version_release_date
         if @release_date_cache.nil?
-          self.class.release_date(name, newest_version)
+          self.class.release_date(name, newest_version, @http)
         else
           @release_date_cache[name, newest_version]
         end
@@ -115,7 +114,8 @@ Maybe you used git in your Gemfile, which libyear doesn't support yet. Contribut
       def versions_sequence
         @_versions_sequence ||= begin
           uri = URI.parse("https://rubygems.org/api/v1/versions/#{name}.json")
-          response = Net::HTTP.get_response(uri)
+          request = Net::HTTP::Get.new(uri)
+          response = @http.request(request)
           parsed_response = JSON.parse(response.body)
           parsed_response.map { |version| version['number'] }
         end

data/lib/libyear_bundler/models/ruby.rb

@@ -62,7 +62,7 @@ module LibyearBundler
 
           # YAML#safe_load provides an already-parsed Date object, so the following
           # is a Date object
-          v['date']
+          @_version_data[v]['date']
         end
 
         private
@@ -84,7 +84,9 @@ module LibyearBundler
               con.request_get(uri.path)
             end
             if response.is_a?(::Net::HTTPSuccess)
-              YAMLLoader.safe_load(response.body).map { |release| release['version'] }
+              @_version_data = YAMLLoader.safe_load(response.body)
+                .map { |release| [release['version'], release] }.to_h
+              @_version_data.keys
             else
               warn format('Unable to get Ruby version list: response code: %s', response.code)
               []

data/lib/libyear_bundler/options.rb

@@ -1,7 +1,6 @@
 require 'optparse'
 require 'libyear_bundler/version'
 require "libyear_bundler/cli"
-require 'ostruct'
 
 module LibyearBundler
   # Uses OptionParser from Ruby's stdlib to hand command-line arguments
@@ -11,14 +10,18 @@ Usage: libyear-bundler [Gemfile ...] [options]
 https://github.com/jaredbeck/libyear-bundler/
     BANNER
 
+    Store = Struct.new(
+      :libyears?, :releases?, :versions?, :cache_path, :grand_total?, :sort?, :json?
+    )
+
     def initialize(argv)
       @argv = argv
-      @options = ::OpenStruct.new
+      @options = Store.new
       @optparser = OptionParser.new do |opts|
         opts.banner = BANNER
         opts.program_name = 'libyear-bundler'
         opts.version = ::LibyearBundler::VERSION
-        @options.send('libyears?=', true)
+        @options.send(:'libyears?=', true)
 
         opts.on_head('-h', '--help', 'Prints this help') do
           puts opts
@@ -26,9 +29,9 @@ https://github.com/jaredbeck/libyear-bundler/
         end
 
         opts.on('--all', 'Calculate all metrics') do
-          @options.send('libyears?=', true)
-          @options.send('releases?=', true)
-          @options.send('versions?=', true)
+          @options.send(:'libyears?=', true)
+          @options.send(:'releases?=', true)
+          @options.send(:'versions?=', true)
         end
 
         opts.on('--cache=CACHE_PATH', 'Use a cache across runs') do |cache_path|
@@ -36,25 +39,29 @@ https://github.com/jaredbeck/libyear-bundler/
         end
 
         opts.on('--libyears', '[default] Calculate libyears out-of-date') do
-          @options.send('libyears?=', true)
+          @options.send(:'libyears?=', true)
         end
 
         opts.on('--releases', 'Calculate number of releases out-of-date') do
-          @options.send('libyears?=', false)
-          @options.send('releases?=', true)
+          @options.send(:'libyears?=', false)
+          @options.send(:'releases?=', true)
         end
 
         opts.on('--versions', 'Calculate major, minor, and patch versions out-of-date') do
-          @options.send('libyears?=', false)
-          @options.send('versions?=', true)
+          @options.send(:'libyears?=', false)
+          @options.send(:'versions?=', true)
         end
 
         opts.on('--grand-total', 'Return value for given metric(s)') do
-          @options.send('grand_total?=', true)
+          @options.send(:'grand_total?=', true)
         end
 
         opts.on('--sort', 'Sort by selected metric(s), in descending order') do
-          @options.send('sort?=', true)
+          @options.send(:'sort?=', true)
+        end
+
+        opts.on('--json', 'Output JSON') do
+          @options.send(:'json?=', true)
         end
       end
     end

data/lib/libyear_bundler/release_date_cache.rb

@@ -8,6 +8,8 @@ module LibyearBundler
     def initialize(data)
       raise TypeError unless data.is_a?(Hash)
       @data = data
+      uri = URI('https://rubygems.org')
+      @http = Net::HTTP.start(uri.host, uri.port, use_ssl: true)
     end
 
     def [](name, version)
@@ -52,7 +54,7 @@ module LibyearBundler
       if name == 'ruby'
         Models::Ruby.release_date(version)
       else
-        Models::Gem.release_date(name, version)
+        Models::Gem.release_date(name, version, @http)
       end
     end
   end

data/lib/libyear_bundler/reports/base.rb

@@ -0,0 +1,87 @@
+module LibyearBundler
+  module Reports
+    # Base class for all reporters. Should only be concerned with presentation, nothing else.
+    #
+    # Subclasses should implement the `#write` method.
+    class Base
+      # `gems` - Array of `::LibyearBundler::Models::Gem` instances
+      # `options` - Instance of `::LibyearBundler::Options`
+      def initialize(gems, ruby, options, io)
+        @gems = gems
+        @ruby = ruby
+        @options = options
+        @io = io
+      end
+
+      def write
+        raise NoMethodError, "Implement in subclass"
+      end
+
+      def to_h
+        @_to_h ||=
+          begin
+            gems = sorted_gems(@gems)
+            summary = {
+              gems: gems,
+              sum_libyears: 0.0
+            }
+            gems.each { |gem| increment_metrics_summary(gem, summary) }
+
+            begin
+              increment_metrics_summary(@ruby, summary) if @ruby.outdated?
+            rescue StandardError => e
+              warn "Unable to calculate libyears for ruby itself: #{e}"
+            end
+
+            summary
+          end
+      end
+
+      private
+
+      def sorted_gems(gems)
+        if @options.sort?
+          gems.sort_by do |gem|
+            [
+              (gem.libyears if @options.libyears?),
+              (gem.version_sequence_delta if @options.releases?),
+              (gem.version_number_delta if @options.versions?)
+            ].compact
+          end.reverse
+        else
+          gems
+        end
+      end
+
+      def increment_metrics_summary(model, summary)
+        increment_libyears(model, summary) if @options.libyears?
+        increment_version_deltas(model, summary) if @options.versions?
+        increment_seq_deltas(model, summary) if @options.releases?
+      end
+
+      def increment_libyears(model, memo)
+        memo[:sum_libyears] += model.libyears
+      rescue StandardError => e
+        warn "Unable to calculate libyears for #{model.name}: #{e}"
+      end
+
+      def increment_seq_deltas(model, memo)
+        memo[:sum_seq_delta] ||= 0
+        memo[:sum_seq_delta] += model.version_sequence_delta
+      rescue StandardError => e
+        warn "Unable to calculate seq deltas for #{model.name}: #{e}"
+      end
+
+      def increment_version_deltas(model, memo)
+        memo[:sum_major_version] ||= 0
+        memo[:sum_major_version] += model.version_number_delta[0]
+        memo[:sum_minor_version] ||= 0
+        memo[:sum_minor_version] += model.version_number_delta[1]
+        memo[:sum_patch_version] ||= 0
+        memo[:sum_patch_version] += model.version_number_delta[2]
+      rescue StandardError => e
+        warn "Unable to calculate version deltas for #{model.name}: #{e}"
+      end
+    end
+  end
+end

data/lib/libyear_bundler/reports/console.rb

@@ -0,0 +1,102 @@
+require "libyear_bundler/reports/base"
+
+module LibyearBundler
+  module Reports
+    # Responsible presenting data from the `::LibyearBundler::Models`. Should only
+    # be concerned with presentation, nothing else.
+    class Console < Base
+      FMT_LIBYEARS_COLUMN = "%10.1f".freeze
+      FMT_RELEASES_COLUMN = "%10d".freeze
+      FMT_VERSIONS_COLUMN = "%15s".freeze
+      FMT_SUMMARY_COLUMNS = "%30s%15s%15s%15s%15s".freeze
+
+      def write
+        to_h[:gems].each { |gem| put_line_summary(gem) }
+
+        begin
+          put_line_summary(@ruby) if @ruby.outdated?
+        rescue StandardError => e
+          warn "Unable to calculate libyears for ruby itself: #{e} (line summary)"
+        end
+
+        put_summary(to_h)
+      end
+
+      private
+
+      def put_line_summary(gem_or_ruby)
+        meta = meta_line_summary(gem_or_ruby)
+
+        if @options.releases?
+          releases = format(FMT_RELEASES_COLUMN, gem_or_ruby.version_sequence_delta)
+          meta << releases
+        end
+
+        if @options.versions?
+          versions = format(FMT_VERSIONS_COLUMN, gem_or_ruby.version_number_delta)
+          meta << versions
+        end
+
+        if @options.libyears?
+          libyears = format(FMT_LIBYEARS_COLUMN, gem_or_ruby.libyears)
+          meta << libyears
+        end
+
+        @io.puts meta
+      end
+
+      def meta_line_summary(gem_or_ruby)
+        format(
+          FMT_SUMMARY_COLUMNS,
+          gem_or_ruby.name,
+          gem_or_ruby.installed_version.to_s,
+          gem_or_ruby.installed_version_release_date,
+          gem_or_ruby.newest_version.to_s,
+          gem_or_ruby.newest_version_release_date
+        )
+      end
+
+      def put_libyear_summary(sum_libyears)
+        @io.puts format("System is %.1f libyears behind", sum_libyears)
+      end
+
+      def put_version_delta_summary(sum_major_version, sum_minor_version, sum_patch_version)
+        @io.puts format(
+          "Major, minor, patch versions behind: %<major>d, %<minor>d, %<patch>d",
+          major: sum_major_version || 0,
+          minor: sum_minor_version || 0,
+          patch: sum_patch_version || 0
+        )
+      end
+
+      def put_sum_seq_delta_summary(sum_seq_delta)
+        @io.puts format(
+          "Total releases behind: %<seq_delta>d",
+          seq_delta: sum_seq_delta || 0
+        )
+      end
+
+      def put_summary(summary)
+        if [:libyears?, :releases?, :versions?].all? { |opt| @options.send(opt) }
+          put_libyear_summary(summary[:sum_libyears])
+          put_sum_seq_delta_summary(summary[:sum_seq_delta])
+          put_version_delta_summary(
+            summary[:sum_major_version],
+            summary[:sum_minor_version],
+            summary[:sum_patch_version]
+          )
+        elsif @options.versions?
+          put_version_delta_summary(
+            summary[:sum_major_version],
+            summary[:sum_minor_version],
+            summary[:sum_patch_version]
+          )
+        elsif @options.releases?
+          put_sum_seq_delta_summary(summary[:sum_seq_delta])
+        elsif @options.libyears?
+          put_libyear_summary(summary[:sum_libyears])
+        end
+      end
+    end
+  end
+end

data/lib/libyear_bundler/reports/json.rb

@@ -0,0 +1,52 @@
+require 'json'
+require 'libyear_bundler/reports/base'
+
+module LibyearBundler
+  module Reports
+    # Responsible for generating data from the `::LibyearBundler::Models` in JSON format.
+    # Should only be concerned with presentation, nothing else.
+    class JSON < Base
+      def write
+        data = {
+          gems: to_h[:gems].map { |gem| gem_info(gem) },
+          ruby: gem_info(@ruby)
+        }
+        data[:sum_libyears] = to_h[:sum_libyears].round(1) if @options.libyears?
+        data[:sum_seq_delta] = to_h[:sum_seq_delta].round(1) if @options.releases?
+        if @options.versions?
+          data[:sum_major_version] = to_h[:sum_major_version].round(1)
+          data[:sum_minor_version] = to_h[:sum_minor_version].round(1)
+          data[:sum_patch_version] = to_h[:sum_patch_version].round(1)
+        end
+
+        @io.puts ::JSON.pretty_generate(data)
+      end
+
+      private
+
+      def gem_info(gem_or_ruby)
+        info = {
+          name: gem_or_ruby.name,
+          installed_version: gem_or_ruby.installed_version.to_s,
+          installed_version_release_date: gem_or_ruby.installed_version_release_date,
+          newest_version: gem_or_ruby.newest_version.to_s,
+          newest_version_release_date: gem_or_ruby.newest_version_release_date
+        }
+
+        if @options.releases?
+          info[:releases] = gem_or_ruby.version_sequence_delta
+        end
+
+        if @options.versions?
+          info[:versions] = [:major, :minor, :patch].zip(gem_or_ruby.version_number_delta).to_h
+        end
+
+        if @options.libyears?
+          info[:libyears] = gem_or_ruby.libyears.round(1)
+        end
+
+        info
+      end
+    end
+  end
+end

data/lib/libyear_bundler/version.rb

@@ -1,3 +1,3 @@
 module LibyearBundler
-  VERSION = "0.8.0".freeze
+  VERSION = "0.9.1".freeze
 end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: libyear-bundler
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.9.1
 platform: ruby
 authors:
 - Jared Beck
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-09-14 00:00:00.000000000 Z
+date: 2025-10-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -30,7 +29,6 @@ dependencies:
     - - "<"
       - !ruby/object:Gem::Version
         version: '3'
-description:
 email:
 - jared@jaredbeck.com
 executables:
@@ -50,7 +48,9 @@ files:
 - lib/libyear_bundler/models/ruby.rb
 - lib/libyear_bundler/options.rb
 - lib/libyear_bundler/release_date_cache.rb
-- lib/libyear_bundler/report.rb
+- lib/libyear_bundler/reports/base.rb
+- lib/libyear_bundler/reports/console.rb
+- lib/libyear_bundler/reports/json.rb
 - lib/libyear_bundler/version.rb
 - lib/libyear_bundler/yaml_loader.rb
 - libyear-bundler.gemspec
@@ -58,7 +58,6 @@ homepage: https://libyear.com
 licenses:
 - GPL-3.0-only
 metadata: {}
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -73,8 +72,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.16
-signing_key:
+rubygems_version: 3.6.2
 specification_version: 4
 summary: A simple measure of dependency freshness
 test_files: []

data/lib/libyear_bundler/report.rb

@@ -1,171 +0,0 @@
-module LibyearBundler
-  # Responsible presenting data from the `::LibyearBundler::Models`. Should only
-  # be concerned with presentation, nothing else.
-  class Report
-    FMT_LIBYEARS_COLUMN = "%10.1f".freeze
-    FMT_RELEASES_COLUMN = "%10d".freeze
-    FMT_VERSIONS_COLUMN = "%15s".freeze
-    FMT_SUMMARY_COLUMNS = "%30s%15s%15s%15s%15s".freeze
-
-    # `gems` - Array of `::LibyearBundler::Models::Gem` instances
-    # `options` - Instance of `::LibyearBundler::Options`
-    def initialize(gems, ruby, options, io)
-      @gems = gems
-      @ruby = ruby
-      @options = options
-      @io = io
-    end
-
-    def write
-      to_h[:gems].each { |gem| put_line_summary(gem) }
-
-      begin
-        put_line_summary(@ruby) if @ruby.outdated?
-      rescue StandardError => e
-        warn "Unable to calculate libyears for ruby itself: #{e} (line summary)"
-      end
-
-      put_summary(to_h)
-    end
-
-    def to_h
-      @_to_h ||=
-        begin
-          gems = sorted_gems(@gems)
-          summary = {
-            gems: gems,
-            sum_libyears: 0.0
-          }
-          gems.each { |gem| increment_metrics_summary(gem, summary) }
-
-          begin
-            increment_metrics_summary(@ruby, summary) if @ruby.outdated?
-          rescue StandardError => e
-            warn "Unable to calculate libyears for ruby itself: #{e}"
-          end
-
-          summary
-        end
-    end
-
-    private
-
-    def sorted_gems(gems)
-      if @options.sort?
-        gems.sort_by do |gem|
-          [
-            (gem.libyears if @options.libyears?),
-            (gem.version_sequence_delta if @options.releases?),
-            (gem.version_number_delta if @options.versions?)
-          ].compact
-        end.reverse
-      else
-        gems
-      end
-    end
-
-    def increment_metrics_summary(model, summary)
-      increment_libyears(model, summary) if @options.libyears?
-      increment_version_deltas(model, summary) if @options.versions?
-      increment_seq_deltas(model, summary) if @options.releases?
-    end
-
-    def put_line_summary(gem_or_ruby)
-      meta = meta_line_summary(gem_or_ruby)
-
-      if @options.releases?
-        releases = format(FMT_RELEASES_COLUMN, gem_or_ruby.version_sequence_delta)
-        meta << releases
-      end
-
-      if @options.versions?
-        versions = format(FMT_VERSIONS_COLUMN, gem_or_ruby.version_number_delta)
-        meta << versions
-      end
-
-      if @options.libyears?
-        libyears = format(FMT_LIBYEARS_COLUMN, gem_or_ruby.libyears)
-        meta << libyears
-      end
-
-      @io.puts meta
-    end
-
-    def meta_line_summary(gem_or_ruby)
-      format(
-        FMT_SUMMARY_COLUMNS,
-        gem_or_ruby.name,
-        gem_or_ruby.installed_version.to_s,
-        gem_or_ruby.installed_version_release_date,
-        gem_or_ruby.newest_version.to_s,
-        gem_or_ruby.newest_version_release_date
-      )
-    end
-
-    def put_libyear_summary(sum_libyears)
-      @io.puts format("System is %.1f libyears behind", sum_libyears)
-    end
-
-    def put_version_delta_summary(sum_major_version, sum_minor_version, sum_patch_version)
-      @io.puts format(
-        "Major, minor, patch versions behind: %<major>d, %<minor>d, %<patch>d",
-        major: sum_major_version || 0,
-        minor: sum_minor_version || 0,
-        patch: sum_patch_version || 0
-      )
-    end
-
-    def put_sum_seq_delta_summary(sum_seq_delta)
-      @io.puts format(
-        "Total releases behind: %<seq_delta>d",
-        seq_delta: sum_seq_delta || 0
-      )
-    end
-
-    def put_summary(summary)
-      if [:libyears?, :releases?, :versions?].all? { |opt| @options.send(opt) }
-        put_libyear_summary(summary[:sum_libyears])
-        put_sum_seq_delta_summary(summary[:sum_seq_delta])
-        put_version_delta_summary(
-          summary[:sum_major_version],
-          summary[:sum_minor_version],
-          summary[:sum_patch_version]
-        )
-      elsif @options.versions?
-        put_version_delta_summary(
-          summary[:sum_major_version],
-          summary[:sum_minor_version],
-          summary[:sum_patch_version]
-        )
-      elsif @options.releases?
-        put_sum_seq_delta_summary(summary[:sum_seq_delta])
-      elsif @options.libyears?
-        put_libyear_summary(summary[:sum_libyears])
-      end
-    end
-
-    def increment_libyears(model, memo)
-      memo[:sum_libyears] += model.libyears
-    rescue StandardError => e
-      warn "Unable to calculate libyears for #{model.name}: #{e}"
-    end
-
-    def increment_seq_deltas(model, memo)
-      memo[:sum_seq_delta] ||= 0
-      memo[:sum_seq_delta] += model.version_sequence_delta
-    rescue StandardError => e
-      warn "Unable to calculate seq deltas for #{model.name}: #{e}"
-    end
-
-    def increment_version_deltas(model, memo)
-      memo[:sum_major_version] ||= 0
-      memo[:sum_major_version] += model.version_number_delta[0]
-      memo[:sum_minor_version] ||= 0
-      memo[:sum_minor_version] += model.version_number_delta[1]
-      memo[:sum_patch_version] ||= 0
-      memo[:sum_patch_version] += model.version_number_delta[2]
-    rescue StandardError => e
-      warn "Unable to calculate version deltas for #{model.name}: #{e}"
-    end
-  end
-end