libyear-bundler 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 734b3af6eedfa8bd832666a33e04ccf4d36dbcec
-  data.tar.gz: 70d4f09011a3102403bec195b4638d7dbbbc73d8
+  metadata.gz: 2bc00352e31430c9a27e420073d5284a343a840a
+  data.tar.gz: 10d60b3b473df24f7a7a6140a22d4ed8bfe7f8a8
 SHA512:
-  metadata.gz: cb0e53a70abcd38aba307d8ea2dac3ffbace0192cd26a8f2b2de960a42c36e6aa4fbae86d951dbfa9eab27796dddbd73d10e8fa7fbfb952dc3e3795bcc595e61
-  data.tar.gz: 65b896dcdbbbc1feea606390b5a20b54680c95e8feb763989a651d1e646f11c2799d83c0e7c54c9c40ca1d464d67fcec3932eb15c2e058b08ad30384d28d8a31
+  metadata.gz: ec414ad1bb5b06517e6fa39fd7ebf1265a8ea42c36f1a9bf225d16bac46fcb61df3f97506725204bd3563b5425f02e28ff5e847bbfbdf8fcc0eaf1a06373be92
+  data.tar.gz: 0e3f53fc0fa0a497abd545e4e91eaa1d82e399d54401cf982393c6db3ff3b28c248a20f4e9d68e8b08d68d3f27e6b4daff1e88ac9bb7e5e82c240eb00d8d2ca9

data/.rubocop.yml

@@ -0,0 +1,11 @@
+Metrics/AbcSize:
+  Max: 27
+
+Metrics/LineLength:
+  Max: 100
+
+Metrics/MethodLength:
+  Enabled: false
+
+Style/StringLiterals:
+  Enabled: false

data/CHANGELOG.md

@@ -17,6 +17,21 @@ Fixed:
 
 - None
 
+## 0.4.0 (2017-07-07)
+
+Breaking changes:
+
+- None
+
+Added:
+
+- [#3](https://github.com/jaredbeck/libyear-bundler/pull/3)
+  Add --versions and --releases
+
+Fixed:
+
+- None
+
 ## 0.3.0 (2017-03-24)
 
 Breaking changes:

data/lib/libyear_bundler/calculators/libyear.rb

@@ -0,0 +1,50 @@
+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(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
+        years
+      end
+
+      private
+
+      # 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/calculators/version_number_delta.rb

@@ -0,0 +1,44 @@
+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(gem)
+        newest_version_tuple = version_tuple(gem[:newest][:version].split('.'))
+        installed_version_tuple = version_tuple(gem[:installed][:version].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

data/lib/libyear_bundler/calculators/version_sequence_delta.rb

@@ -0,0 +1,20 @@
+require 'net/http'
+require 'uri'
+require 'json'
+
+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(gem)
+        uri = URI.parse("https://rubygems.org/api/v1/versions/#{gem[:name]}.json")
+        response = Net::HTTP.get_response(uri)
+        versions = JSON.parse(response.body).map { |version| version["number"] }
+        newest_seq = versions.index(gem[:newest][:version])
+        installed_seq = versions.index(gem[:installed][:version])
+        installed_seq - newest_seq
+      end
+    end
+  end
+end

data/lib/libyear_bundler/cli.rb

@@ -4,10 +4,15 @@ require "libyear_bundler/report"
 require "libyear_bundler/query"
 
 module LibyearBundler
+  # The `libyear-bundler` command line program
   class CLI
-    OPTIONS = %w(
+    OPTIONS = %w[
+      --all
       --grand-total
-    ).freeze
+      --libyears
+      --releases
+      --versions
+    ].freeze
 
     E_BUNDLE_OUTDATED_FAILED = 1
     E_NO_GEMFILE = 2
@@ -22,7 +27,7 @@ module LibyearBundler
       if @argv.include?("--grand-total")
         grand_total
       else
-        print Report.new(query).to_s
+        print report.to_s
       end
     end
 
@@ -51,7 +56,11 @@ module LibyearBundler
     end
 
     def query
-      Query.new(@gemfile_path).execute
+      Query.new(@gemfile_path, @argv).execute
+    end
+
+    def report
+      @_report ||= Report.new(query)
     end
 
     def unexpected_options
@@ -64,16 +73,46 @@ module LibyearBundler
     end
 
     def validate_arguments
-      unless unexpected_options.empty?
-        puts "Unexpected args: #{unexpected_options.join(", ")}"
-        puts "Allowed args: #{OPTIONS.join(", ")}"
-        exit E_NO_GEMFILE
-      end
+      return if unexpected_options.empty?
+      puts "Unexpected args: #{unexpected_options.join(', ')}"
+      puts "Allowed args: #{OPTIONS.join(', ')}"
+      exit E_NO_GEMFILE
     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 report.to_h.key?(:sum_seq_delta) && report.to_h.key?(:sum_major_version)
+        [
+          libyears_grand_total,
+          releases_grand_total,
+          versions_grand_total
+        ].join("\n")
+      elsif report.to_h.key?(:sum_seq_delta)
+        releases_grand_total
+      elsif report.to_h.key?(:sum_major_version)
+        versions_grand_total
+      else
+        libyears_grand_total
+      end
+    end
+
+    def libyears_grand_total
+      report.to_h[:sum_years].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/query.rb

@@ -1,5 +1,8 @@
 require "English"
 require "open3"
+require 'libyear_bundler/calculators/libyear'
+require 'libyear_bundler/calculators/version_number_delta'
+require 'libyear_bundler/calculators/version_sequence_delta'
 
 module LibyearBundler
   # Responsible for getting all the data that goes into the `Report`.
@@ -7,8 +10,9 @@ module LibyearBundler
     # Format of `bundle outdated --parseable` (BOP)
     BOP_FMT = /\A(?<name>[^ ]+) \(newest (?<newest>[^,]+), installed (?<installed>[^,)]+)/
 
-    def initialize(gemfile_path)
+    def initialize(gemfile_path, argv)
       @gemfile_path = gemfile_path
+      @argv = argv
     end
 
     def execute
@@ -23,19 +27,15 @@ module LibyearBundler
         )
       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
+        if @argv.include?("--versions") || @argv.include?("--all")
+          gem[:version_number_delta] = ::Calculators::VersionNumberDelta.calculate(gem)
         end
-        gem[:libyears] = years
+
+        if @argv.include?("--releases") || @argv.include?("--all")
+          gem[:version_sequence_delta] = ::Calculators::VersionSequenceDelta.calculate(gem)
+        end
+
+        gem[:libyears] = ::Calculators::Libyear.calculate(gem)
       end
       gems
     end
@@ -44,7 +44,7 @@ module LibyearBundler
 
     def bundle_outdated
       stdout, stderr, status = Open3.capture3(
-        %Q(BUNDLE_GEMFILE="#{@gemfile_path}" bundle outdated --parseable)
+        %(BUNDLE_GEMFILE="#{@gemfile_path}" bundle outdated --parseable)
       )
       # Known statuses:
       # 0 - Nothing is outdated
@@ -59,30 +59,5 @@ module LibyearBundler
       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

data/lib/libyear_bundler/report.rb

@@ -2,29 +2,115 @@ module LibyearBundler
   # Responsible presenting data from the `Query`. Should only be concerned
   # with presentation, nothing else.
   class Report
+    FMT_RELEASES_COLUMN = "%10d".freeze
+    FMT_VERSIONS_COLUMN = "%15s".freeze
+
     # `gems` - Array of hashes.
     def initialize(gems)
       @gems = gems
     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_gem_summary(gem) }
+      put_summary(to_h)
+    end
+
+    def to_h
+      @_to_h ||=
+        begin
+          summary = {
+            gems: @gems,
+            sum_years: 0.0
+          }
+          @gems.each_with_object(summary) do |gem, memo|
+            memo[:sum_years] += gem[:libyears]
+
+            if gem.key?(:version_number_delta)
+              memo[:sum_major_version] ||= 0
+              memo[:sum_major_version] += gem[:version_number_delta][0]
+              memo[:sum_minor_version] ||= 0
+              memo[:sum_minor_version] += gem[:version_number_delta][1]
+              memo[:sum_patch_version] ||= 0
+              memo[:sum_patch_version] += gem[:version_number_delta][2]
+            end
+
+            if gem.key?(:version_sequence_delta)
+              memo[:sum_seq_delta] ||= 0
+              memo[:sum_seq_delta] += gem[:version_sequence_delta]
+            end
+          end
+        end
+    end
+
+    private
+
+    def put_gem_summary(gem)
+      meta = meta_gem_summary(gem)
+      libyear = format("%10.1f", gem[:libyears])
+
+      if gem.key?(:version_sequence_delta) && gem.key?(:version_number_delta)
+        releases = format(FMT_RELEASES_COLUMN, gem[:version_sequence_delta])
+        versions = format(FMT_VERSIONS_COLUMN, gem[:version_number_delta])
+        puts meta << libyear << releases << versions
+      elsif gem.key?(:version_sequence_delta)
+        releases = format(FMT_RELEASES_COLUMN, gem[:version_sequence_delta])
+        puts meta << releases
+      elsif gem.key?(:version_number_delta)
+        versions = format(FMT_VERSIONS_COLUMN, gem[:version_number_delta])
+        puts meta << versions
+      else
+        puts meta << libyear
       end
+    end
+
+    def meta_gem_summary(gem)
+      format(
+        "%30s%15s%15s%15s%15s",
+        gem[:name],
+        gem[:installed][:version],
+        gem[:installed][:date],
+        gem[:newest][:version],
+        gem[:newest][:date]
+      )
+    end
+
+    def put_libyear_summary(sum_years)
       puts format("System is %.1f libyears behind", sum_years)
     end
+
+    def put_version_delta_summary(sum_major_version, sum_minor_version, sum_patch_version)
+      puts format(
+        "Major, minor, patch versions behind: %d, %d, %d",
+        sum_major_version,
+        sum_minor_version,
+        sum_patch_version
+      )
+    end
+
+    def put_sum_seq_delta_summary(sum_seq_delta)
+      puts format("Total releases behind: %d", sum_seq_delta)
+    end
+
+    def put_summary(summary)
+      if summary.key?(:sum_seq_delta) && summary.key?(:sum_major_version)
+        put_libyear_summary(summary[:sum_years])
+        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 summary.key?(:sum_major_version)
+        put_version_delta_summary(
+          summary[:sum_major_version],
+          summary[:sum_minor_version],
+          summary[:sum_patch_version]
+        )
+      elsif summary.key?(:sum_seq_delta)
+        put_sum_seq_delta_summary(summary[:sum_seq_delta])
+      else
+        put_libyear_summary(summary[:sum_years])
+      end
+    end
   end
 end

data/lib/libyear_bundler/version.rb

@@ -1,3 +1,3 @@
 module LibyearBundler
-  VERSION = "0.3.0"
+  VERSION = "0.4.0".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'
@@ -19,4 +20,5 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
   spec.required_ruby_version = ">= 2.1"
   spec.add_dependency "bundler", "~> 1.14"
+  spec.add_development_dependency "rubocop"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: libyear-bundler
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Jared Beck
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-03-24 00:00:00.000000000 Z
+date: 2017-07-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -24,6 +24,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.14'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: 
 email:
 - jared@jaredbeck.com
@@ -33,12 +47,17 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".rubocop.yml"
 - CHANGELOG.md
 - Gemfile
 - LICENSE.txt
 - README.md
+- asd
 - bin/libyear-bundler
 - lib/libyear_bundler.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/report.rb
@@ -64,7 +83,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.11
+rubygems_version: 2.6.12
 signing_key: 
 specification_version: 4
 summary: A simple measure of dependency freshness