libyear-bundler 0.3.0 → 0.5.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 734b3af6eedfa8bd832666a33e04ccf4d36dbcec
-  data.tar.gz: 70d4f09011a3102403bec195b4638d7dbbbc73d8
+  metadata.gz: 19cf55f9516aaf1b3ea4e870df4786d871844aec
+  data.tar.gz: 1f9ed94b7ce2d79bdebbb07fa8d59e2d7bfc6d5c
 SHA512:
-  metadata.gz: cb0e53a70abcd38aba307d8ea2dac3ffbace0192cd26a8f2b2de960a42c36e6aa4fbae86d951dbfa9eab27796dddbd73d10e8fa7fbfb952dc3e3795bcc595e61
-  data.tar.gz: 65b896dcdbbbc1feea606390b5a20b54680c95e8feb763989a651d1e646f11c2799d83c0e7c54c9c40ca1d464d67fcec3932eb15c2e058b08ad30384d28d8a31
+  metadata.gz: '09111fa6dbb524adb6f3a6af71f2fcd4803451f22e3d6d289cb61d8ef926553c781ddd3b801f33d7bbb7d957ea8fac52388982d752bb96625feedb3fd304aca2'
+  data.tar.gz: 7c9f3884523e18478563d45d5f35ef4f34f8b5d60d5fca78c369420a32dd3de6d3070e298347cc15d486c80405e357e0926b140abaf07e3d8d7a515dd664a91e

data/lib/libyear_bundler/bundle_outdated.rb

@@ -0,0 +1,63 @@
+require "English"
+require "open3"
+require 'libyear_bundler/calculators/libyear'
+require 'libyear_bundler/calculators/version_number_delta'
+require 'libyear_bundler/calculators/version_sequence_delta'
+require 'libyear_bundler/models/gem'
+
+module LibyearBundler
+  # Responsible for getting all the data that goes into the `Report`.
+  class BundleOutdated
+    # Format of `bundle outdated --parseable` (BOP)
+    BOP_FMT = /\A(?<name>[^ ]+) \(newest (?<newest>[^,]+), installed (?<installed>[^,)]+)/
+
+    def initialize(gemfile_path)
+      @gemfile_path = gemfile_path
+    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
+
+        gem = ::LibyearBundler::Models::Gem.new(
+          match['name'],
+          match['installed'],
+          match['newest']
+        )
+        gems.push(gem)
+      end
+    end
+
+    private
+
+    def bundle_outdated
+      stdout, stderr, status = Open3.capture3(
+        %(BUNDLE_GEMFILE="#{@gemfile_path}" bundle outdated --parseable)
+      )
+      # Known statuses:
+      # 0 - Nothing is outdated
+      # 256 - Something is outdated
+      # 1792 - Unable to determine if something is outdated
+      unless [0, 256].include?(status.to_i)
+        $stderr.puts "`bundle outdated` failed with status: #{status.to_i}"
+        $stderr.puts "stderr: #{stderr}"
+        $stderr.puts "stdout: #{stdout}"
+        $stderr.puts "Try running `bundle install`."
+        Kernel.exit(CLI::E_BUNDLE_OUTDATED_FAILED)
+      end
+      stdout
+    end
+
+    # We rely on Gem::Version to handle version strings. If the string is malformed (usually because
+    # of a gem installed from git), then we won't be able to determine the dependency's freshness
+    def malformed_version_strings?(dependency)
+      !Gem::Version.correct?(dependency['installed']) ||
+        !Gem::Version.correct?(dependency['newest'])
+    end
+  end
+end

data/lib/libyear_bundler/calculators/libyear.rb

@@ -0,0 +1,23 @@
+module LibyearBundler
+  module Calculators
+    # A libyear is the difference in time between releases of the newest and
+    # installed versions of the gem in years
+    class Libyear
+      class << self
+        def calculate(installed_version_release_date, newest_version_release_date)
+          di = installed_version_release_date
+          dn = newest_version_release_date
+          if di.nil? || dn.nil? || dn <= di
+            # Known issue: Backports and maintenance releases of older minor versions.
+            # Example: json 1.8.6 (2017-01-13) was released *after* 2.0.3 (2017-01-12)
+            years = 0.0
+          else
+            days = (dn - di).to_f
+            years = days / 365.0
+          end
+          years
+        end
+      end
+    end
+  end
+end

data/lib/libyear_bundler/calculators/version_number_delta.rb

@@ -0,0 +1,46 @@
+module LibyearBundler
+  module Calculators
+    # The version number delta is the absolute difference between the highest-
+    # order version number of the installed and newest releases
+    class VersionNumberDelta
+      class << self
+        def calculate(installed_version, newest_version)
+          installed_version_tuple = version_tuple(installed_version.to_s.split('.'))
+          newest_version_tuple = version_tuple(newest_version.to_s.split('.'))
+          major_version_delta = version_delta(
+            newest_version_tuple.major, installed_version_tuple.major
+          )
+          minor_version_delta = version_delta(
+            newest_version_tuple.minor, installed_version_tuple.minor
+          )
+          patch_version_delta = version_delta(
+            newest_version_tuple.patch, installed_version_tuple.patch
+          )
+          highest_order([major_version_delta, minor_version_delta, patch_version_delta])
+        end
+
+        private
+
+        def highest_order(arr)
+          arr[1] = arr[2] = 0 if arr[0] > 0
+          arr[2] = 0 if arr[1] > 0
+          arr
+        end
+
+        def version_delta(newest_version, installed_version)
+          delta = newest_version - installed_version
+          delta < 0 ? 0 : delta
+        end
+
+        def version_tuple(version_array)
+          version_struct = Struct.new(:major, :minor, :patch)
+          version_struct.new(
+            version_array[0].to_i,
+            version_array[1].to_i,
+            version_array[2].to_i
+          )
+        end
+      end
+    end
+  end
+end

data/lib/libyear_bundler/calculators/version_sequence_delta.rb

@@ -0,0 +1,13 @@
+module LibyearBundler
+  module Calculators
+    # The version sequence delta is the number of releases between the newest and
+    # installed versions of the gem
+    class VersionSequenceDelta
+      class << self
+        def calculate(installed_seq_index, newest_seq_index)
+          installed_seq_index - newest_seq_index
+        end
+      end
+    end
+  end
+end

data/lib/libyear_bundler/cli.rb

@@ -1,28 +1,31 @@
 require "bundler/cli"
 require "bundler/cli/outdated"
+require "libyear_bundler/bundle_outdated"
+require "libyear_bundler/options"
 require "libyear_bundler/report"
-require "libyear_bundler/query"
+require 'libyear_bundler/models/ruby'
 
 module LibyearBundler
+  # The `libyear-bundler` command line program
   class CLI
-    OPTIONS = %w(
-      --grand-total
-    ).freeze
-
     E_BUNDLE_OUTDATED_FAILED = 1
     E_NO_GEMFILE = 2
+    E_INVALID_CLI_ARG = 3
 
     def initialize(argv)
+      @options = ::LibyearBundler::Options.new(argv).parse
+      # Command line flags are removed form `argv` in `Options` by
+      # `OptionParser`, leaving non-flag command line arguments,
+      # such as a Gemfile path
       @argv = argv
       @gemfile_path = load_gemfile_path
-      validate_arguments
     end
 
     def run
-      if @argv.include?("--grand-total")
+      if @options.grand_total?
         grand_total
       else
-        print Report.new(query).to_s
+        print report.to_s
       end
     end
 
@@ -46,34 +49,57 @@ module LibyearBundler
         '' # `bundle outdated` will default to local Gemfile
       else
         $stderr.puts "Gemfile not found"
-        exit
+        exit E_NO_GEMFILE
       end
     end
 
-    def query
-      Query.new(@gemfile_path).execute
+    def bundle_outdated
+      BundleOutdated.new(@gemfile_path).execute
     end
 
-    def unexpected_options
-      @_unexpected_options ||= begin
-        options = @argv.select { |arg| arg.start_with?("--") }
-        options.each_with_object([]) do |arg, memo|
-          memo << arg unless OPTIONS.include?(arg)
-        end
-      end
+    def report
+      @_report ||= Report.new(bundle_outdated, ruby, @options)
     end
 
-    def validate_arguments
-      unless unexpected_options.empty?
-        puts "Unexpected args: #{unexpected_options.join(", ")}"
-        puts "Allowed args: #{OPTIONS.join(", ")}"
-        exit E_NO_GEMFILE
-      end
+    def ruby
+      lockfile = @gemfile_path + '.lock'
+      ::LibyearBundler::Models::Ruby.new(lockfile)
     end
 
     def grand_total
-      sum_years = query.map { |gem| gem[:libyears] }.inject(0.0, :+)
-      puts format("%.1f", sum_years)
+      puts calculate_grand_total
+    end
+
+    def calculate_grand_total
+      if [:libyears?, :releases?, :versions?].all? { |opt| @options[opt] }
+        [
+          libyears_grand_total,
+          releases_grand_total,
+          versions_grand_total
+        ].join("\n")
+      elsif @options.releases?
+        releases_grand_total
+      elsif @options.versions?
+        versions_grand_total
+      else
+        libyears_grand_total
+      end
+    end
+
+    def libyears_grand_total
+      report.to_h[:sum_libyears].truncate(1)
+    end
+
+    def releases_grand_total
+      report.to_h[:sum_seq_delta]
+    end
+
+    def versions_grand_total
+      [
+        report.to_h[:sum_major_version],
+        report.to_h[:sum_minor_version],
+        report.to_h[:sum_patch_version]
+      ].to_s
     end
   end
 end

data/lib/libyear_bundler/models/gem.rb

@@ -0,0 +1,104 @@
+require 'net/http'
+require 'uri'
+require 'json'
+
+module LibyearBundler
+  module Models
+    # Logic and information pertaining to the installed and newest versions of
+    # a gem
+    class Gem
+      def initialize(name, installed_version, newest_version)
+        @name = name
+        @installed_version = installed_version
+        @newest_version = newest_version
+      end
+
+      def installed_version
+        ::Gem::Version.new(@installed_version)
+      end
+
+      def installed_version_release_date
+        release_date(name, installed_version)
+      end
+
+      def installed_version_sequence_index
+        versions_sequence.index(installed_version.to_s)
+      end
+
+      def libyears
+        ::LibyearBundler::Calculators::Libyear.calculate(
+          installed_version_release_date,
+          newest_version_release_date
+        )
+      end
+
+      def name
+        @name
+      end
+
+      def newest_version
+        ::Gem::Version.new(@newest_version)
+      end
+
+      def newest_version_sequence_index
+        versions_sequence.index(newest_version.to_s)
+      end
+
+      def newest_version_release_date
+        release_date(name, newest_version)
+      end
+
+      def version_number_delta
+        ::LibyearBundler::Calculators::VersionNumberDelta.calculate(
+          installed_version,
+          newest_version
+        )
+      end
+
+      def version_sequence_delta
+        ::LibyearBundler::Calculators::VersionSequenceDelta.calculate(
+          installed_version_sequence_index,
+          newest_version_sequence_index
+        )
+      end
+
+      private
+
+      # docs: http://guides.rubygems.org/rubygems-org-api/#gem-version-methods
+      # Versions are returned ordered by version number, descending
+      def versions_sequence
+        @_versions_sequence ||= begin
+          uri = URI.parse("https://rubygems.org/api/v1/versions/#{name}.json")
+          response = Net::HTTP.get_response(uri)
+          parsed_response = JSON.parse(response.body)
+          parsed_response.map { |version| version['number'] }
+        end
+      end
+
+      # Known issue: Probably performs a network request every time, unless
+      # there's some kind of caching.
+      def release_date(gem_name, gem_version)
+        dep = nil
+        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."
+          )
+          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}"
+          return nil
+        end
+        tup, source = tuples.first # Gem::NameTuple
+        spec = source.fetch_spec(tup) # raises Gem::RemoteFetcher::FetchError
+        spec.date.to_date
+      end
+    end
+  end
+end

data/lib/libyear_bundler/models/ruby.rb

@@ -0,0 +1,155 @@
+require 'bundler/lockfile_parser'
+require 'bundler/ruby_version'
+require 'date'
+require 'net/http'
+require 'yaml'
+
+require 'libyear_bundler/calculators/libyear'
+require 'libyear_bundler/calculators/version_number_delta'
+require 'libyear_bundler/calculators/version_sequence_delta'
+
+module LibyearBundler
+  module Models
+    # Logic and information pertaining to the installed and newest Ruby versions
+    class Ruby
+      RUBY_VERSION_DATA_URL = "https://raw.githubusercontent.com/ruby/" \
+        "www.ruby-lang.org/master/_data/releases.yml".freeze
+
+      def initialize(lockfile)
+        @lockfile = lockfile
+      end
+
+      def installed_version
+        @_installed_version ||= begin
+          version_from_bundler ||
+            version_from_ruby_version_file ||
+            version_from_ruby
+        end
+      end
+
+      def installed_version_release_date
+        release_date(installed_version.to_s)
+      end
+
+      def libyears
+        ::LibyearBundler::Calculators::Libyear.calculate(
+          release_date(installed_version.to_s),
+          release_date(newest_version.to_s)
+        )
+      end
+
+      def name
+        'ruby'
+      end
+
+      def newest_version
+        ::Gem::Version.new(all_stable_versions.first)
+      end
+
+      def newest_version_release_date
+        release_date(newest_version.to_s)
+      end
+
+      def outdated?
+        installed_version < newest_version
+      end
+
+      def version_number_delta
+        ::LibyearBundler::Calculators::VersionNumberDelta.calculate(
+          installed_version,
+          newest_version
+        )
+      end
+
+      def version_sequence_delta
+        ::LibyearBundler::Calculators::VersionSequenceDelta.calculate(
+          installed_version_sequence_index,
+          newest_version_sequence_index
+        )
+      end
+
+      private
+
+      # The following URL is the only official, easily-parseable document with
+      # Ruby version information that I'm aware of, but is not supported as such
+      # (https://github.com/ruby/www.ruby-lang.org/pull/1637#issuecomment-344934173).
+      # It's been recommend that ruby-lang.org provide a supported document:
+      # https://github.com/ruby/www.ruby-lang.org/pull/1637#issuecomment-344934173
+      # TODO: Use supported document with version information if it becomes
+      # available.
+      def all_versions
+        @_all_versions ||= begin
+          uri = ::URI.parse(RUBY_VERSION_DATA_URL)
+          response = ::Net::HTTP.get_response(uri)
+          # The Date object is passed through here due to a bug in
+          # YAML#safe_load
+          # https://github.com/ruby/psych/issues/262
+          ::YAML.safe_load(response.body, [Date])
+            .map { |release| release['version'] }
+        end
+      end
+
+      # We'll only consider non-prerelease versions when analyzing ruby version,
+      # which we also implcitly do for gem versions because that's bundler's
+      # default behavior
+      def all_stable_versions
+        all_versions.reject do |version|
+          ::Gem::Version.new(version).prerelease?
+        end
+      end
+
+      def installed_version_sequence_index
+        all_stable_versions.index(installed_version.to_s)
+      end
+
+      def newest_version_sequence_index
+        all_stable_versions.find_index(newest_version.to_s)
+      end
+
+      def release_date(version)
+        v = all_stable_versions.detect { |ver| ver == version }
+
+        if v.nil?
+          raise format('Cannot determine release date for ruby %s', version)
+        end
+
+        # YAML#safe_load provides an already-parsed Date object, so the following
+        # is a Date object
+        v['date']
+      end
+
+      def shell_out_to_ruby
+        # ruby appends a 'p' followed by the patch level number
+        # to the version number for stable releases, which returns
+        # a false positive using `::Gem::Version#prerelease?`.
+        # Understandably, because ruby is not a gem, but we'd like
+        # to use `prerelease?`.
+        # Pre-releases are appended with 'dev', and so adhere to
+        # `::Gem::Version`'s definition of a pre-release.
+        # Sources:
+        #   - https://github.com/ruby/ruby/blob/trunk/version.h#L37
+        #   - https://ruby-doc.org/stdlib-1.9.3/libdoc/rubygems/rdoc/Version.html
+        `ruby --version`.split[1].gsub(/p\d*/, '')
+      end
+
+      def version_from_bundler
+        return unless File.exist?(@lockfile)
+        ruby_version_string = ::Bundler::LockfileParser
+          .new(@lockfile)
+          .ruby_version
+        return if ruby_version_string.nil?
+
+        ::Bundler::RubyVersion.from_string(ruby_version_string).gem_version
+      end
+
+      def version_from_ruby_version_file
+        return unless ::File.exist?('.ruby-version')
+        ::Gem::Version.new(::File.read('.ruby-version').strip)
+      end
+
+      def version_from_ruby
+        ::Gem::Version.new(shell_out_to_ruby)
+      end
+    end
+  end
+end

data/lib/libyear_bundler/options.rb

@@ -0,0 +1,63 @@
+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
+  class Options
+    BANNER = <<-BANNER.freeze
+Usage: libyear-bundler [Gemfile ...] [options]
+https://github.com/jaredbeck/libyear-bundler/
+    BANNER
+
+    def initialize(argv)
+      @argv = argv
+      @options = ::OpenStruct.new
+      @optparser = OptionParser.new do |opts|
+        opts.banner = BANNER
+        opts.program_name = 'libyear-bundler'
+        opts.version = ::LibyearBundler::VERSION
+        @options.send('libyears?=', true)
+
+        opts.on_head('-h', '--help', 'Prints this help') do
+          puts opts
+          exit
+        end
+
+        opts.on('--all', 'Calculate all metrics') do
+          @options.send('libyears?=', true)
+          @options.send('releases?=', true)
+          @options.send('versions?=', true)
+        end
+
+        opts.on('--libyears', '[default] Calculate libyears out-of-date') do
+          @options.send('libyears?=', true)
+        end
+
+        opts.on('--releases', 'Calculate number of releases out-of-date') do
+          @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)
+        end
+
+        opts.on('--grand-total', 'Return value for given metric(s)') do
+          @options.send('grand_total?=', true)
+        end
+      end
+    end
+
+    def parse
+      @optparser.parse!(@argv)
+      @options
+    rescue OptionParser::InvalidOption => e
+      warn e
+      warn @optparser.help
+      exit ::LibyearBundler::CLI::E_INVALID_CLI_ARG
+    end
+  end
+end

data/lib/libyear_bundler/report.rb

@@ -1,30 +1,149 @@
 module LibyearBundler
-  # Responsible presenting data from the `Query`. Should only be concerned
-  # with presentation, nothing else.
+  # Responsible presenting data from the `::LibyearBundler::Models`. Should only
+  # be concerned with presentation, nothing else.
   class Report
-    # `gems` - Array of hashes.
-    def initialize(gems)
+    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)
       @gems = gems
+      @ruby = ruby
+      @options = options
     end
 
     def to_s
-      sum_years = 0.0
-      @gems.each do |gem|
-        years = gem[:libyears]
-        sum_years += years
-        puts(
-          format(
-            "%30s%15s%15s%15s%15s%10.1f",
-            gem[:name],
-            gem[:installed][:version],
-            gem[:installed][:date],
-            gem[:newest][:version],
-            gem[:newest][:date],
-            years
-          )
+      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
+
+      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)
+      puts format("System is %.1f libyears behind", sum_libyears)
+    end
+
+    def put_version_delta_summary(sum_major_version, sum_minor_version, sum_patch_version)
+      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)
+      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
-      puts format("System is %.1f libyears behind", sum_years)
+    end
+
+    def increment_libyears(model, memo)
+      memo[:sum_libyears] += model.libyears
+    end
+
+    def increment_seq_deltas(model, memo)
+      memo[:sum_seq_delta] ||= 0
+      memo[:sum_seq_delta] += model.version_sequence_delta
+    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]
     end
   end
 end

data/lib/libyear_bundler/version.rb

@@ -1,3 +1,3 @@
 module LibyearBundler
-  VERSION = "0.3.0"
+  VERSION = "0.5.3".freeze
 end

data/libyear-bundler.gemspec

@@ -1,4 +1,5 @@
 # coding: utf-8
+
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'libyear_bundler/version'
@@ -11,12 +12,26 @@ Gem::Specification.new do |spec|
   spec.summary = "A simple measure of dependency freshness"
   spec.homepage = "https://libyear.com"
   spec.licenses = ["GPL-3.0"]
-  spec.files = `git ls-files -z`.split("\x0").reject do |f|
-    f.match(%r{^(test|spec|features)/})
+  spec.files = `git ls-files -z`.split("\x0").select do |f|
+    f.start_with?('lib/') ||
+      [
+        'bin/libyear-bundler',
+        'libyear-bundler.gemspec',
+        'LICENSE.txt'
+      ].include?(f)
   end
   spec.bindir = "bin"
   spec.executables = ["libyear-bundler"]
   spec.require_paths = ["lib"]
   spec.required_ruby_version = ">= 2.1"
-  spec.add_dependency "bundler", "~> 1.14"
+
+  # We will support bundler 1 as long as we can. It's important that people
+  # with badly out-of-date systems can still measure how bad they are.
+  spec.add_dependency "bundler", ">= 1.14", "< 3"
+
+  spec.add_development_dependency "rspec", "~> 3.9"
+
+  # rubocop 0.57 drops support for ruby 2.1, so 0.56 is the highest we can
+  # use. We're going to support ruby 2.1 as long as possible. See above.
+  spec.add_development_dependency "rubocop", "~> 0.56.0"
 end

metadata

@@ -1,29 +1,63 @@
 --- !ruby/object:Gem::Specification
 name: libyear-bundler
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.5.3
 platform: ruby
 authors:
 - Jared Beck
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-03-24 00:00:00.000000000 Z
+date: 2020-06-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '1.14'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '1.14'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.9'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.56.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.56.0
 description: 
 email:
 - jared@jaredbeck.com
@@ -32,15 +66,17 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
-- ".gitignore"
-- CHANGELOG.md
-- Gemfile
 - LICENSE.txt
-- README.md
 - bin/libyear-bundler
 - lib/libyear_bundler.rb
+- lib/libyear_bundler/bundle_outdated.rb
+- lib/libyear_bundler/calculators/libyear.rb
+- lib/libyear_bundler/calculators/version_number_delta.rb
+- lib/libyear_bundler/calculators/version_sequence_delta.rb
 - lib/libyear_bundler/cli.rb
-- lib/libyear_bundler/query.rb
+- lib/libyear_bundler/models/gem.rb
+- lib/libyear_bundler/models/ruby.rb
+- lib/libyear_bundler/options.rb
 - lib/libyear_bundler/report.rb
 - lib/libyear_bundler/version.rb
 - libyear-bundler.gemspec
@@ -64,7 +100,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.11
+rubygems_version: 2.5.2.3
 signing_key: 
 specification_version: 4
 summary: A simple measure of dependency freshness

data/.gitignore

@@ -1,10 +0,0 @@
-/.bundle/
-/.yardoc
-/Gemfile.lock
-/_yardoc/
-/coverage/
-/doc/
-/pkg/
-/spec/reports/
-/tmp/
-.ruby-version

data/CHANGELOG.md

@@ -1,100 +0,0 @@
-# libyear
-
-This project follows [semver 2.0.0][1] and the recommendations
-of [keepachangelog.com][2].
-
-## Unreleased
-
-Breaking changes:
-
-- None
-
-Added:
-
-- None
-
-Fixed:
-
-- None
-
-## 0.3.0 (2017-03-24)
-
-Breaking changes:
-
-- None
-
-Added:
-
-- [#1](https://github.com/jaredbeck/libyear-bundler/pull/1)
-  Add --grand-total option
-
-Fixed:
-
-- None
-
-## 0.2.0 (2017-03-10)
-
-Breaking changes:
-
-- Rename project
-  - Rename project from libyear-rb to libyear-bundler
-  - Rename binary from libyear to libyear-bundler
-  - Discussion: https://github.com/jaredbeck/libyear-rb/issues/1
-
-Added:
-
-- None
-
-Fixed:
-
-- None
-
-## 0.1.3 (2017-03-07)
-
-Breaking changes:
-
-- None
-
-Added:
-
-- None
-
-Fixed:
-
-- Don't crash when Gemfile uses git
-
-## 0.1.2 (2017-02-16)
-
-Breaking changes:
-
-- None
-
-Added:
-
-- None
-
-Fixed:
-
-- Better handling of weird sources like rails-assets
-- Wider report columns
-
-## 0.1.1 (2017-02-14)
-
-Breaking changes:
-
-- None
-
-Added:
-
-- None
-
-Fixed:
-
-- Better handling of error when bundle outdated fails
-
-## 0.1.0 (2017-02-13)
-
-Initial version. Proof of concept.
-
-[1]: http://semver.org/spec/v2.0.0.html
-[2]: http://keepachangelog.com/

data/Gemfile

@@ -1,4 +0,0 @@
-source 'https://rubygems.org'
-
-# Specify your gem's dependencies in libyear.gemspec
-gemspec

data/README.md

@@ -1,30 +0,0 @@
-# Libyear
-
-A simple measure of dependency freshness for ruby apps.
-
-A libyear (library year) is a measure of how old a software dependency is.
-
-If your system has two dependencies, the first one year old, the second three,
-then your system is four libyears out-of-date.
-
-A dependency is one year old when the version you are using is one year older
-than its latest version.
-
-## Usage
-
-Early access. Output and usage subject to change.
-
-```
-gem install libyear-bundler
-libyear-bundler Gemfile
-       activesupport   4.2.7.1     2016-08-10     5.0.1     2016-12-21       0.4
-                json     1.8.6     2017-01-13     2.0.3     2017-01-12       0.0
-   minitest_to_rspec     0.6.0     2015-06-09     0.8.0     2017-01-02       1.6
-System is 1.9 libyears behind
-```
-
-## Development
-
-```
-ruby -I lib bin/libyear-bundler spec/fixtures/01/Gemfile
-```

data/lib/libyear_bundler/query.rb

@@ -1,88 +0,0 @@
-require "English"
-require "open3"
-
-module LibyearBundler
-  # Responsible for getting all the data that goes into the `Report`.
-  class Query
-    # Format of `bundle outdated --parseable` (BOP)
-    BOP_FMT = /\A(?<name>[^ ]+) \(newest (?<newest>[^,]+), installed (?<installed>[^,)]+)/
-
-    def initialize(gemfile_path)
-      @gemfile_path = gemfile_path
-    end
-
-    def execute
-      gems = []
-      bundle_outdated.lines.each do |line|
-        match = BOP_FMT.match(line)
-        next if match.nil?
-        gems.push(
-          installed: { version: match["installed"] },
-          name: match["name"],
-          newest: { version: match["newest"] }
-        )
-      end
-      gems.each do |gem|
-        di = release_date(gem[:name], gem[:installed][:version])
-        dn = release_date(gem[:name], gem[:newest][:version])
-        gem[:installed][:date] = di
-        gem[:newest][:date] = dn
-        if di.nil? || dn.nil? || dn <= di
-          # Known issue: Backports and maintenance releases of older minor versions.
-          # Example: json 1.8.6 (2017-01-13) was released *after* 2.0.3 (2017-01-12)
-          years = 0.0
-        else
-          days = (dn - di).to_f
-          years = days / 365.0
-        end
-        gem[:libyears] = years
-      end
-      gems
-    end
-
-    private
-
-    def bundle_outdated
-      stdout, stderr, status = Open3.capture3(
-        %Q(BUNDLE_GEMFILE="#{@gemfile_path}" bundle outdated --parseable)
-      )
-      # Known statuses:
-      # 0 - Nothing is outdated
-      # 256 - Something is outdated
-      # 1792 - Unable to determine if something is outdated
-      unless [0, 256].include?(status.to_i)
-        $stderr.puts "`bundle outdated` failed with status: #{status.to_i}"
-        $stderr.puts "stderr: #{stderr}"
-        $stderr.puts "stdout: #{stdout}"
-        $stderr.puts "Try running `bundle install`."
-        Kernel.exit(CLI::E_BUNDLE_OUTDATED_FAILED)
-      end
-      stdout
-    end
-
-    # Known issue: Probably performs a network request every time, unless
-    # there's some kind of caching.
-    def release_date(gem_name, gem_version)
-      dep = nil
-      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."
-        )
-        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}"
-        return nil
-      end
-      tup, source = tuples.first # Gem::NameTuple
-      spec = source.fetch_spec(tup) # raises Gem::RemoteFetcher::FetchError
-      spec.date.to_date
-    end
-  end
-end