libyear-bundler 0.7.0 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e4f90004a4a8f93453f73361a0e3415344017e83f55d10d625b0a3b69f1db74b
-  data.tar.gz: 55d91c831ae79f5b44c6de0bcd2f68e550590d73d5004646c1da0163abbcebea
+  metadata.gz: 0423ad3e6d453baa3bc6bc93e49a3aa72fa7918a81d6b2403fb6546a8d078193
+  data.tar.gz: 56e00c648efe514f290533f33921d1da2b3c460702721a6b402b03c09a953813
 SHA512:
-  metadata.gz: e3b1346dbdc4986e539fba595f18e01a46fd03d647210b34a6810e2bd9ae61028ffa00eae7e4e2c4088f524368a2cc74950f5d79610ab6aa2bd93d5c4cdd9e6a
-  data.tar.gz: 2196cc0fe1a16f2fd9ea4646eb7d07a227d58f07dc5f2cca3724c8ae4b08d4386adbdbc51f3364f2891745e7202b106348dabefed1734a6eb3b11c38823e4f17
+  metadata.gz: 694fbd117515873bacb006cac6f10442170c7439b82ea861dcd02e56128589d8c88e38c3cef1b09e9eff93e4c938c50e900a8845f1e09a8e87376e5dac2a4e9f
+  data.tar.gz: ef72774c6db0dbb48ae72ec3c0ff52bc56912aa7915637843db8bc7b7608db188232f3dab1da308f714312e552da1e4c955f54fba6061e45d64b7e60b42f5798

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

@@ -23,23 +23,32 @@ module LibyearBundler
           begin
             dep = ::Bundler::Dependency.new(gem_name, gem_version)
           rescue ::Gem::Requirement::BadRequirementError => e
-            $stderr.puts "Could not find release date for: #{gem_name}"
-            $stderr.puts(e)
-            $stderr.puts(
-              "Maybe you used git in your Gemfile, which libyear doesn't support " \
-              "yet. Contributions welcome."
-            )
+            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
           end
           tuples, _errors = ::Gem::SpecFetcher.fetcher.search_for_dependency(dep)
           if tuples.empty?
-            $stderr.puts "Could not find release date for: #{gem_name}"
+            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
         end
+
+        private
+
+        def report_problem(gem_name, message)
+          @reported_gems ||= {}
+          @reported_gems[gem_name] ||= begin
+            $stderr.puts(message)
+            true
+          end
+        end
       end
 
       def installed_version

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

@@ -52,6 +52,14 @@ https://github.com/jaredbeck/libyear-bundler/
         opts.on('--grand-total', 'Return value for given metric(s)') do
           @options.send('grand_total?=', true)
         end
+
+        opts.on('--sort', 'Sort by selected metric(s), in descending order') do
+          @options.send('sort?=', true)
+        end
+
+        opts.on('--json', 'Output JSON') do
+          @options.send('json?=', true)
+        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.7.0".freeze
+  VERSION = "0.9.0".freeze
 end

data/libyear-bundler.gemspec

@@ -11,7 +11,7 @@ Gem::Specification.new do |spec|
   spec.email = ["jared@jaredbeck.com"]
   spec.summary = "A simple measure of dependency freshness"
   spec.homepage = "https://libyear.com"
-  spec.licenses = ["GPL-3.0"]
+  spec.licenses = ["GPL-3.0-only"]
   spec.files = `git ls-files -z`.split("\x0").select do |f|
     f.start_with?('lib/') ||
       [

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: libyear-bundler
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.9.0
 platform: ruby
 authors:
 - Jared Beck
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-05-11 00:00:00.000000000 Z
+date: 2025-03-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -50,13 +50,15 @@ 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
 homepage: https://libyear.com
 licenses:
-- GPL-3.0
+- GPL-3.0-only
 metadata: {}
 post_install_message: 
 rdoc_options: []

data/lib/libyear_bundler/report.rb

@@ -1,156 +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
-          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 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