bundleup 1.3.0 → 2.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: db5d58970165c2381d963205eae11b610d57f35e9654bee2edff54f2d1ff861f
-  data.tar.gz: 508d1cba2d3ab7c2167b60ec38fd1bf49e0252f614e07fe7cce3ed36de3dc32e
+  metadata.gz: f8a962e269c6e12d142a5e7e464044acdf1ffd80e4a75939fc6f5be7a2a19ad1
+  data.tar.gz: 86692adf1c57156cf441e2dc7b8aba2fe9f424fe1e93c3abb075e1db7b38a22e
 SHA512:
-  metadata.gz: c8133402453232bfd33b17a9c3c5f903874f92f190063bc84e7f29723514ab5333d791d0ac2e6eb4c8deb75a5d5f734a20cb47d63101a79ff879b8e566c63952
-  data.tar.gz: c508a0e3360b51d537c948e1cd95790fd69ad01d43d86a97976729fea4737a84aa25fedd69513f379c26ba82c0abcea3f71bc3f25ad1e802845b24c81f3deb9e
+  metadata.gz: c288f7fdcc1b441a1bd027303ef0270870d6a36be2272d0c4e4984f04612a1d69a847ae73e47db9dba4fd6eba326c5d44cb7b256a860221cb975dc04a7ae283b
+  data.tar.gz: 7891c266cc969b16a66e1ab5ef245fbf6119218972e4ed94317bc2488e914863176e49eba0ce04aea634df1be51c827f4d9357ddad9be1fb5a6f63ae2b09e09f

data/LICENSE.txt

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2020 Matt Brictson
+Copyright (c) 2021 Matt Brictson
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -1,7 +1,7 @@
 # bundleup
 
 [![Gem Version](https://badge.fury.io/rb/bundleup.svg)](http://badge.fury.io/rb/bundleup)
-[![Build Status](https://travis-ci.org/mattbrictson/bundleup.svg?branch=main)](https://travis-ci.org/mattbrictson/bundleup)
+[![Build Status](https://circleci.com/gh/mattbrictson/bundleup/tree/main.svg?style=shield)](https://app.circleci.com/pipelines/github/mattbrictson/bundleup?branch=main)
 
 **Run `bundleup` on a Ruby project containing a Gemfile to see what gem dependencies need updating.** It is a friendlier command-line interface to [Bundler’s][bundler] `bundle update` and `bundle outdated`.
 
@@ -14,7 +14,7 @@ You might like bundleup because it:
 
 Here it is in action:
 
-<img src="https://raw.github.com/mattbrictson/bundleup/main/sample.png" width="599" height="553" alt="Sample output">
+<img src="./demo.gif" width="682" height="351" alt="Sample output">
 
 ## Requirements
 
@@ -44,7 +44,37 @@ Protip: Any extra command-line arguments will be passed along to `bundle update`
 bundleup --group=development
 ```
 
-## How it works
+### Experimental: `--update-gemfile`
+
+> 💡 This is an experimental feature that may be removed or changed in future versions.
+
+Normally bundleup only makes changes to your Gemfile.lock. It honors the version restrictions ("pins") in your Gemfile and will not update your Gemfile.lock to have versions that are not allowed. However with the `--update-gemfile` flag, bundleup can update the version pins in your Gemfile as well. Consider the following Gemfile:
+
+```ruby
+gem 'sidekiq', '~> 5.2'
+gem 'rubocop', '0.89.0'
+```
+
+Normally running `bundleup` will report that these gems are pinned and therefore cannot be updated to the latest versions. However, if you pass the `--update-gemfile` option like this:
+
+```
+$ bundleup --update-gemfile
+```
+
+Now bundleup will automatically edit your Gemfile pins as needed to bring those gems up to date. For example, bundleup would change the Gemfile to look like this:
+
+```ruby
+gem 'sidekiq', '~> 6.1'
+gem 'rubocop', '0.90.0'
+```
+
+Note that `--update-gemfile` will _not_ modify Gemfile entries that contain a comment, like this:
+
+```ruby
+gem 'sidekiq', '~> 5.2' # our monkey patch doesn't work on 6.0+
+```
+
+## How bundleup works
 
 bundleup starts by making a backup copy of your Gemfile.lock. Next it runs `bundle check` (and `bundle install` if any gems are missing in your local environment), `bundle list`, then `bundle update` and `bundle list` again to find what gems versions are being used before and after Bundler does its updating magic. (Since gems are actually being installed into your Ruby environment during these steps, the process may take a few moments to complete, especially if gems with native extensions need to be compiled.)
 
@@ -54,7 +84,7 @@ After displaying its findings, bundleup gives you the option of keeping the chan
 
 ## Roadmap
 
-bundleup is a very simple script at this point, but it could be more. Some possibilities:
+bundleup is very simple at this point, but it could be more. Some possibilities:
 
 - Automatically commit the Gemfile.lock changes with a nice commit message
 - Integrate with bundler-audit to mark upgrades that have important security fixes

data/exe/bundleup

@@ -1,4 +1,10 @@
 #!/usr/bin/env ruby
 
 require "bundleup"
-Bundleup::CLI.new.run
+
+begin
+  Bundleup::CLI.new(ARGV).run
+rescue Bundleup::CLI::Error => e
+  Bundleup.logger.error(e.message)
+  exit(false)
+end

data/lib/bundleup.rb

@@ -1,8 +1,22 @@
 require "bundleup/version"
-require "bundleup/console"
-require "bundleup/bundle_commands"
-require "bundleup/gem_status"
-require "bundleup/gemfile"
-require "bundleup/outdated_parser"
-require "bundleup/upgrade"
+require "bundleup/backup"
+require "bundleup/colors"
 require "bundleup/cli"
+require "bundleup/commands"
+require "bundleup/gemfile"
+require "bundleup/logger"
+require "bundleup/report"
+require "bundleup/shell"
+require "bundleup/pin_report"
+require "bundleup/update_report"
+require "bundleup/version_spec"
+
+module Bundleup
+  class << self
+    attr_accessor :commands, :logger, :shell
+  end
+end
+
+Bundleup.commands = Bundleup::Commands.new
+Bundleup.logger = Bundleup::Logger.new
+Bundleup.shell = Bundleup::Shell.new

data/lib/bundleup/backup.rb

@@ -0,0 +1,29 @@
+module Bundleup
+  class Backup
+    def self.restore_on_error(*paths)
+      backup = new(*paths)
+      begin
+        yield(backup)
+      rescue StandardError, Interrupt
+        backup.restore
+        raise
+      end
+    end
+
+    def initialize(*paths)
+      @original_contents = paths.each_with_object({}) do |path, hash|
+        hash[path] = IO.read(path)
+      end
+    end
+
+    def restore
+      original_contents.each do |path, contents|
+        IO.write(path, contents)
+      end
+    end
+
+    private
+
+    attr_reader :original_contents
+  end
+end

data/lib/bundleup/cli.rb

@@ -1,86 +1,148 @@
+require "forwardable"
+
 module Bundleup
   class CLI
-    include Console
-
-    def run
-      puts \
-        "Please wait a moment while I upgrade your Gemfile.lock..."
-
-      committed = false
-      review_upgrades
-      review_pins
-      committed = upgrades.any? && confirm_commit
-      puts "Done!" if committed
-    ensure
-      restore_lockfile unless committed
-    end
+    Error = Class.new(StandardError)
 
-    private
+    include Colors
+    extend Forwardable
+    def_delegators :Bundleup, :commands, :logger
 
-    def review_upgrades
-      if upgrades.any?
-        puts "\nThe following gem(s) will be updated:\n\n"
-        print_upgrades_table
-      else
-        ok("Nothing to update.")
+    def initialize(args)
+      @args = args.dup
+      @update_gemfile = @args.delete("--update-gemfile")
+    end
+
+    def run # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      print_usage && return if (args & %w[-h --help]).any?
+
+      assert_gemfile_and_lock_exist!
+
+      logger.puts "Please wait a moment while I upgrade your Gemfile.lock..."
+      Backup.restore_on_error("Gemfile", "Gemfile.lock") do |backup|
+        perform_analysis_and_optionally_bump_gemfile_versions do |update_report, pin_report|
+          if update_report.empty?
+            logger.ok "Nothing to update."
+            logger.puts "\n#{pin_report}" unless pin_report.empty?
+            break
+          end
+
+          logger.puts
+          logger.puts update_report
+          logger.puts pin_report unless pin_report.empty?
+
+          if logger.confirm?("Do you want to apply these changes?")
+            logger.ok "Done!"
+          else
+            backup.restore
+            logger.puts "Your original Gemfile.lock has been restored."
+          end
+        end
       end
     end
 
-    def review_pins
-      return if pins.empty?
+    private
 
-      puts "\nNote that the following gem(s) are being held back:\n\n"
-      print_pins_table
-    end
+    attr_reader :args
 
-    def confirm_commit
-      confirm("\nDo you want to apply these changes?")
-    end
+    def print_usage # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      logger.puts(<<~USAGE.gsub(/^/, "  "))
 
-    def restore_lockfile
-      return unless defined?(@upgrade)
-      return unless upgrade.lockfile_changed?
+        Usage: #{green('bundleup')} #{yellow('[GEMS...] [OPTIONS]')}
 
-      upgrade.undo
-      puts "Your original Gemfile.lock has been restored."
-    end
+        Use #{blue('bundleup')} in place of #{blue('bundle update')} to interactively update your project
+        Gemfile.lock to the latest gem versions. Bundleup will show what gems will
+        be updated, color-code them based on semver, and ask you to confirm the
+        updates before finalizing them. For example:
 
-    def upgrade
-      @upgrade ||= Upgrade.new(ARGV)
-    end
+            The following gems will be updated:
 
-    def upgrades
-      upgrade.upgrades
-    end
+            #{yellow('bundler-audit 0.6.1   → 0.7.0.1')}
+            i18n          1.8.2   → 1.8.5
+            #{red('json          2.2.0   → (removed)')}
+            parser        2.7.1.1 → 2.7.1.4
+            #{red('rails         e063bef → 57a4ead')}
+            #{blue('rubocop-ast   (new)   → 0.3.0')}
+            #{red('thor          0.20.3  → 1.0.1')}
+            #{yellow('zeitwerk      2.3.0   → 2.4.0')}
+
+            #{yellow('Do you want to apply these changes [Yn]?')}
+
+        Bundleup will also let you know if there are gems that can't be updated
+        because they are pinned in the Gemfile. Any relevant comments from the
+        Gemfile will also be included, explaining the pins:
+
+            Note that the following gems are being held back:
 
-    def pins
-      upgrade.pins
+            rake    12.3.3 → 13.0.1 : pinned at ~> 12.0   #{gray('# Not ready for 13 yet')}
+            rubocop 0.89.0 → 0.89.1 : pinned at  = 0.89.0
+
+        You may optionally specify one or more #{yellow('GEMS')} or pass #{yellow('OPTIONS')} to bundleup;
+        these will be passed through to bundler. See #{blue('bundle update --help')} for the
+        full list of the options that bundler supports.
+
+        Finally, bundleup also supports an experimental #{yellow('--update-gemfile')} option.
+        If specified, bundleup with modify the version restrictions specified in
+        your Gemfile so that it can install the latest version of each gem. For
+        instance, if your Gemfile specifies #{yellow('gem "sidekiq", "~> 5.2"')} but an update
+        to version 6.1.2 is available, bundleup will modify the Gemfile entry to
+        be #{yellow('gem "sidekiq", "~> 6.1"')} in order to permit the update.
+
+        Examples:
+
+            #{gray('# Update all gems')}
+            #{blue('$ bundleup')}
+
+            #{gray('# Only update gems in the development group')}
+            #{blue('$ bundleup --group=development')}
+
+            #{gray('# Only update the rake gem')}
+            #{blue('$ bundleup rake')}
+
+            #{gray('# Experimental: modify Gemfile to allow the latest gem versions')}
+            #{blue('$ bundleup --update-gemfile')}
+
+      USAGE
+      true
     end
 
-    def print_upgrades_table
-      rows = tableize(upgrades) do |g|
-        [g.name, g.old_version || "(new)", "→", g.new_version || "(removed)"]
-      end
-      upgrades.zip(rows).each do |g, row|
-        puts color(g.color, row)
-      end
+    def assert_gemfile_and_lock_exist!
+      return if File.exist?("Gemfile") && File.exist?("Gemfile.lock")
+
+      raise Error, "Gemfile and Gemfile.lock must both be present."
     end
 
-    def print_pins_table
-      rows = tableize(pins) do |g|
-        [g.name, g.new_version, "→", g.newest_version, *pin_reason(g)]
+    def perform_analysis_and_optionally_bump_gemfile_versions # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      gemfile = Gemfile.new
+      lockfile_backup = Backup.new("Gemfile.lock")
+      update_report, pin_report, _, outdated_gems = perform_analysis
+      updatable_gems = gemfile.gem_pins_without_comments.slice(*outdated_gems.keys)
+
+      if updatable_gems.any? && @update_gemfile
+        lockfile_backup.restore
+        orig_gemfile = Gemfile.new
+        gemfile.relax_gem_pins!(updatable_gems.keys)
+        update_report, pin_report, new_versions, = perform_analysis
+        orig_gemfile.shift_gem_pins!(new_versions.slice(*updatable_gems.keys))
+        commands.install
       end
-      puts rows.join("\n")
-    end
 
-    def pin_reason(gem)
-      notes = color(:gray, gemfile.gem_comment(gem.name))
-      pin_operator, pin_version = gem.pin.split(" ", 2)
-      [":", "pinned at", pin_operator.rjust(2), pin_version, notes]
+      logger.clear_line
+      yield(update_report, pin_report)
     end
 
-    def gemfile
-      @gemfile ||= Gemfile.new
+    def perform_analysis # rubocop:disable Metrics/AbcSize
+      gem_comments = Gemfile.new.gem_comments
+      commands.check? || commands.install
+      old_versions = commands.list
+      commands.update(args)
+      new_versions = commands.list
+      outdated_gems = commands.outdated
+
+      update_report = UpdateReport.new(old_versions: old_versions, new_versions: new_versions)
+      pin_report = PinReport.new(gem_versions: new_versions, outdated_gems: outdated_gems, gem_comments: gem_comments)
+
+      [update_report, pin_report, new_versions, outdated_gems]
     end
   end
 end

data/lib/bundleup/colors.rb

@@ -0,0 +1,56 @@
+module Bundleup
+  module Colors
+    ANSI_CODES = {
+      red: 31,
+      green: 32,
+      yellow: 33,
+      blue: 34,
+      gray: 90
+    }.freeze
+    private_constant :ANSI_CODES
+
+    class << self
+      attr_writer :enabled
+
+      def enabled?
+        return @enabled if defined?(@enabled)
+
+        @enabled = determine_color_support
+      end
+
+      private
+
+      def determine_color_support
+        if ENV["CLICOLOR_FORCE"] == "1"
+          true
+        elsif ENV["TERM"] == "dumb"
+          false
+        else
+          tty?($stdout) && tty?($stderr)
+        end
+      end
+
+      def tty?(io)
+        io.respond_to?(:tty?) && io.tty?
+      end
+    end
+
+    module_function
+
+    def plain(str)
+      str
+    end
+
+    def strip(str)
+      str.gsub(/\033\[[0-9;]*m/, "")
+    end
+
+    ANSI_CODES.each do |name, code|
+      define_method(name) do |str|
+        return str if str.to_s.empty?
+
+        Colors.enabled? ? "\e[0;#{code};49m#{str}\e[0m" : str
+      end
+    end
+  end
+end

data/lib/bundleup/commands.rb

@@ -0,0 +1,40 @@
+require "forwardable"
+
+module Bundleup
+  class Commands
+    GEMFILE_ENTRY_REGEXP = /\* (\S+) \((\S+)(?: (\S+))?\)/.freeze
+    OUTDATED_2_1_REGEXP = /\* (\S+) \(newest (\S+),.* requested (.*)\)/.freeze
+    OUTDATED_2_2_REGEXP = /^(\S+)\s\s+\S+\s\s+(\d\S+)\s\s+(\S.*?)(?:$|\s\s)/.freeze
+
+    extend Forwardable
+    def_delegators :Bundleup, :shell
+
+    def check?
+      shell.run?(%w[bundle check])
+    end
+
+    def install
+      shell.run(%w[bundle install])
+    end
+
+    def list
+      output = shell.capture(%w[bundle list])
+      output.scan(GEMFILE_ENTRY_REGEXP).each_with_object({}) do |(name, ver, sha), gems|
+        gems[name] = sha || ver
+      end
+    end
+
+    def outdated
+      output = shell.capture(%w[bundle outdated], raise_on_error: false)
+      expr = output.match?(/^Gem\s+Current\s+Latest/) ? OUTDATED_2_2_REGEXP : OUTDATED_2_1_REGEXP
+
+      output.scan(expr).each_with_object({}) do |(name, newest, pin), gems|
+        gems[name] = { newest: newest, pin: pin }
+      end
+    end
+
+    def update(args=[])
+      shell.run(%w[bundle update] + args)
+    end
+  end
+end

data/lib/bundleup/gemfile.rb

@@ -1,17 +1,59 @@
 module Bundleup
   class Gemfile
+    attr_reader :path
+
     def initialize(path="Gemfile")
+      @path = path
       @contents = IO.read(path)
     end
 
-    def gem_comment(gem_name)
-      inline_comment(gem_name) || prefix_comment(gem_name)
+    def gem_comments
+      gem_names.each_with_object({}) do |gem_name, hash|
+        comment = inline_comment(gem_name) || prefix_comment(gem_name)
+        hash[gem_name] = comment unless comment.nil?
+      end
+    end
+
+    def gem_pins_without_comments
+      (gem_names - gem_comments.keys).each_with_object({}) do |gem_name, hash|
+        next unless (match = gem_declaration_with_pinned_version_re(gem_name).match(contents))
+
+        version = match[1]
+        hash[gem_name] = VersionSpec.parse(version)
+      end
+    end
+
+    def relax_gem_pins!(gem_names)
+      gem_names.each do |gem_name|
+        rewrite_gem_version!(gem_name, &:relax)
+      end
+    end
+
+    def shift_gem_pins!(new_gem_versions)
+      new_gem_versions.each do |gem_name, new_version|
+        rewrite_gem_version!(gem_name) { |version_spec| version_spec.shift(new_version) }
+      end
     end
 
     private
 
+    def rewrite_gem_version!(gem_name)
+      found = contents.sub!(gem_declaration_with_pinned_version_re(gem_name)) do |match|
+        version = Regexp.last_match[1]
+        match[Regexp.last_match.regexp, 1] = yield(VersionSpec.parse(version)).to_s
+        match
+      end
+      raise "Can't rewrite version for #{gem_name}; it does not have a pin" unless found
+
+      IO.write(path, contents)
+    end
+
     attr_reader :contents
 
+    def gem_names
+      contents.scan(/^\s*gem\s+["'](.+?)["']/).flatten.uniq
+    end
+
     def inline_comment(gem_name)
       contents[/#{gem_declaration_re(gem_name)}.*(#\s*\S+.*)/, 1]
     end
@@ -23,5 +65,9 @@ module Bundleup
     def gem_declaration_re(gem_name)
       /^\s*gem\s+["']#{Regexp.escape(gem_name)}["']/
     end
+
+    def gem_declaration_with_pinned_version_re(gem_name)
+      /#{gem_declaration_re(gem_name)},\s*["']([^'"]+)["']\s*$/
+    end
   end
 end

data/lib/bundleup/logger.rb

@@ -0,0 +1,64 @@
+require "io/console"
+
+module Bundleup
+  class Logger
+    extend Forwardable
+    def_delegators :@stdout, :print, :puts, :tty?
+    def_delegators :@stdin, :gets
+
+    def initialize(stdin: $stdin, stdout: $stdout, stderr: $stderr)
+      @stdin = stdin
+      @stdout = stdout
+      @stderr = stderr
+      @spinner = %w[⠋ ⠙ ⠹ ⠸ ⠼ ⠴ ⠦ ⠧ ⠇ ⠏].cycle
+    end
+
+    def ok(message)
+      puts Colors.green("✔ #{message}")
+    end
+
+    def error(message)
+      stderr.puts Colors.red("ERROR: #{message}")
+    end
+
+    def attention(message)
+      puts Colors.yellow(message)
+    end
+
+    def confirm?(question)
+      print Colors.yellow(question.sub(/\??\z/, " [Yn]? "))
+      gets =~ /^($|y)/i
+    end
+
+    def clear_line
+      print "\r".ljust(console_width - 1)
+      print "\r"
+    end
+
+    def while_spinning(message, &block)
+      thread = Thread.new(&block)
+      thread.report_on_exception = false
+      message = message.ljust(console_width - 2)
+      print "\r#{Colors.blue([spinner.next, message].join(' '))}" until wait_for_exit(thread, 0.1)
+      thread.value
+    end
+
+    private
+
+    attr_reader :spinner, :stderr
+
+    def console_width
+      width = IO.console.winsize.last if tty?
+      width.to_i.positive? ? width : 80
+    end
+
+    def wait_for_exit(thread, seconds)
+      thread.join(seconds)
+    rescue StandardError
+      # Sanity check. If we get an exception, the thread should be dead.
+      raise if thread.alive?
+
+      thread
+    end
+  end
+end

data/lib/bundleup/pin_report.rb

@@ -0,0 +1,37 @@
+module Bundleup
+  class PinReport < Report
+    def initialize(gem_versions:, outdated_gems:, gem_comments:)
+      super()
+      @gem_versions = gem_versions
+      @outdated_gems = outdated_gems
+      @gem_comments = gem_comments
+    end
+
+    def title
+      return "Note that this gem is being held back:" if rows.count == 1
+
+      "Note that the following gems are being held back:"
+    end
+
+    def rows
+      outdated_gems.keys.sort.map do |gem|
+        meta = outdated_gems[gem]
+        current_version = gem_versions[gem]
+        newest_version = meta[:newest]
+        pin = meta[:pin]
+
+        [gem, current_version, "→", newest_version, *pin_reason(gem, pin)]
+      end
+    end
+
+    private
+
+    attr_reader :gem_versions, :outdated_gems, :gem_comments
+
+    def pin_reason(gem, pin)
+      notes = Colors.gray(gem_comments[gem].to_s)
+      pin_operator, pin_version = pin.split(" ", 2)
+      [":", "pinned at", pin_operator.rjust(2), pin_version, notes]
+    end
+  end
+end

data/lib/bundleup/report.rb

@@ -0,0 +1,38 @@
+require "forwardable"
+
+module Bundleup
+  class Report
+    extend Forwardable
+    def_delegators :rows, :empty?, :one?
+
+    def many?
+      rows.length > 1
+    end
+
+    def to_s
+      [
+        title,
+        tableize(rows).map { |row| row.join(" ").rstrip }.join("\n"),
+        ""
+      ].join("\n\n")
+    end
+
+    private
+
+    def tableize(rows)
+      widths = max_length_of_each_column(rows)
+      rows.map do |row|
+        row.zip(widths).map do |value, width|
+          padding = " " * (width - Colors.strip(value).length)
+          "#{value}#{padding}"
+        end
+      end
+    end
+
+    def max_length_of_each_column(rows)
+      Array.new(rows.first.count) do |i|
+        rows.map { |values| Colors.strip(values[i]).length }.max
+      end
+    end
+  end
+end

data/lib/bundleup/shell.rb

@@ -0,0 +1,35 @@
+require "forwardable"
+require "open3"
+
+module Bundleup
+  class Shell
+    extend Forwardable
+    def_delegators :Bundleup, :logger
+
+    def capture(command, raise_on_error: true)
+      stdout, stderr, status = capture3(command)
+      raise ["Failed to execute: #{command}", stdout, stderr].compact.join("\n") if raise_on_error && !status.success?
+
+      stdout
+    end
+
+    def run(command)
+      capture(command)
+      true
+    end
+
+    def run?(command)
+      _, _, status = capture3(command)
+      status.success?
+    end
+
+    private
+
+    def capture3(command)
+      command = Array(command)
+      logger.while_spinning("running: #{command.join(' ')}") do
+        Open3.capture3(*command)
+      end
+    end
+  end
+end

data/lib/bundleup/update_report.rb

@@ -0,0 +1,63 @@
+module Bundleup
+  class UpdateReport < Report
+    def initialize(old_versions:, new_versions:)
+      super()
+      @old_versions = old_versions
+      @new_versions = new_versions
+    end
+
+    def title
+      return "This gem will be updated:" if rows.count == 1
+
+      "The following gems will be updated:"
+    end
+
+    def rows
+      gem_names.each_with_object([]) do |gem, rows|
+        old = old_versions[gem]
+        new = new_versions[gem]
+        next if old == new
+
+        row = [gem, old || "(new)", "→", new || "(removed)"]
+
+        color = color_for_gem(gem)
+        rows << row.map { |col| Colors.public_send(color, col) }
+      end
+    end
+
+    private
+
+    attr_reader :old_versions, :new_versions
+
+    def gem_names
+      (old_versions.keys | new_versions.keys).sort
+    end
+
+    def color_for_gem(gem)
+      old_version = old_versions[gem]
+      new_version = new_versions[gem]
+
+      return :blue if old_version.nil?
+      return :red if new_version.nil? || major_upgrade?(old_version, new_version)
+      return :yellow if minor_upgrade?(old_version, new_version)
+
+      :plain
+    end
+
+    def major_upgrade?(old_version, new_version)
+      major(new_version) != major(old_version)
+    end
+
+    def minor_upgrade?(old_version, new_version)
+      minor(new_version) != minor(old_version)
+    end
+
+    def major(version)
+      version.split(".", 2)[0]
+    end
+
+    def minor(version)
+      version.split(".", 3)[1]
+    end
+  end
+end

data/lib/bundleup/version.rb

@@ -1,3 +1,3 @@
 module Bundleup
-  VERSION = "1.3.0".freeze
+  VERSION = "2.1.3".freeze
 end

data/lib/bundleup/version_spec.rb

@@ -0,0 +1,54 @@
+module Bundleup
+  class VersionSpec
+    def self.parse(version)
+      return version if version.is_a?(VersionSpec)
+
+      version = version.strip
+      _, operator, number = version.match(/^([^\d\s]*)\s*(.+)/).to_a
+      operator = nil if operator.empty?
+
+      new(parts: number.split("."), operator: operator)
+    end
+
+    attr_reader :parts, :operator
+
+    def initialize(parts:, operator: nil)
+      @parts = parts
+      @operator = operator
+    end
+
+    def exact?
+      operator.nil?
+    end
+
+    def relax
+      return self if %w[!= > >=].include?(operator)
+      return self.class.parse(">= 0") if %w[< <=].include?(operator)
+
+      self.class.new(parts: parts, operator: ">=")
+    end
+
+    def shift(new_version) # rubocop:disable Metrics/AbcSize
+      return self.class.parse(new_version) if exact?
+      return self if Gem::Requirement.new(to_s).satisfied_by?(Gem::Version.new(new_version))
+      return self.class.new(parts: self.class.parse(new_version).parts, operator: "<=") if %w[< <=].include?(operator)
+
+      new_slice = self.class.parse(new_version).slice(parts.length)
+      self.class.new(parts: new_slice.parts, operator: "~>")
+    end
+
+    def slice(amount)
+      self.class.new(parts: parts[0, amount], operator: operator)
+    end
+
+    def to_s
+      [operator, parts.join(".")].compact.join(" ")
+    end
+
+    def ==(other)
+      return false unless other.is_a?(VersionSpec)
+
+      to_s == other.to_s
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bundleup
 version: !ruby/object:Gem::Version
-  version: 1.3.0
+  version: 2.1.3
 platform: ruby
 authors:
 - Matt Brictson
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-08-08 00:00:00.000000000 Z
+date: 2021-04-04 00:00:00.000000000 Z
 dependencies: []
 description: Use `bundleup` whenever you want to update the locked Gemfile dependencies
   of a Ruby project. It shows exactly what gems will be updated with color output
@@ -27,14 +27,18 @@ files:
 - README.md
 - exe/bundleup
 - lib/bundleup.rb
-- lib/bundleup/bundle_commands.rb
+- lib/bundleup/backup.rb
 - lib/bundleup/cli.rb
-- lib/bundleup/console.rb
-- lib/bundleup/gem_status.rb
+- lib/bundleup/colors.rb
+- lib/bundleup/commands.rb
 - lib/bundleup/gemfile.rb
-- lib/bundleup/outdated_parser.rb
-- lib/bundleup/upgrade.rb
+- lib/bundleup/logger.rb
+- lib/bundleup/pin_report.rb
+- lib/bundleup/report.rb
+- lib/bundleup/shell.rb
+- lib/bundleup/update_report.rb
 - lib/bundleup/version.rb
+- lib/bundleup/version_spec.rb
 homepage: https://github.com/mattbrictson/bundleup
 licenses:
 - MIT
@@ -58,7 +62,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.4
+rubygems_version: 3.2.15
 signing_key:
 specification_version: 4
 summary: A friendlier command-line interface for Bundler’s `update` and `outdated`

data/lib/bundleup/bundle_commands.rb

@@ -1,52 +0,0 @@
-require "open3"
-
-module Bundleup
-  class BundleCommands
-    class Result
-      attr_reader :output
-
-      def initialize(output, success)
-        @output = output
-        @success = success
-      end
-
-      def success?
-        @success
-      end
-    end
-
-    include Console
-
-    def check
-      run(%w[bundle check], fail_silently: true).success?
-    end
-
-    def install
-      run(%w[bundle install]).output
-    end
-
-    def outdated
-      run(%w[bundle outdated], fail_silently: true).output
-    end
-
-    def list
-      run(%w[bundle list]).output
-    end
-
-    def update(args=[])
-      run(%w[bundle update] + args).output
-    end
-
-    private
-
-    def run(cmd, fail_silently: false)
-      cmd_line = cmd.join(" ")
-      progress("Running `#{cmd_line}`") do
-        out, err, status = Open3.capture3(*cmd)
-        next(Result.new(out, status.success?)) if status.success? || fail_silently
-
-        raise ["Failed to execute: #{cmd_line}", out, err].compact.join("\n")
-      end
-    end
-  end
-end

data/lib/bundleup/console.rb

@@ -1,100 +0,0 @@
-module Bundleup
-  module Console
-    ANSI_CODES = {
-      red: 31,
-      green: 32,
-      yellow: 33,
-      blue: 34,
-      gray: 90
-    }.freeze
-
-    def ok(message)
-      puts color(:green, "✔ #{message}")
-    end
-
-    def attention(message)
-      puts color(:yellow, message)
-    end
-
-    def color(color_name, message)
-      code = ANSI_CODES[color_name]
-      return message if code.nil?
-
-      "\e[0;#{code};49m#{message}\e[0m"
-    end
-
-    def confirm(question)
-      print question.sub(/\??\z/, " [Yn]? ")
-      $stdin.gets =~ /^($|y)/i
-    end
-
-    # Runs a block in the background and displays a spinner until it completes.
-    def progress(message, &block)
-      spinner = %w[/ - \\ |].cycle
-      print "\e[90m#{message}... \e[0m"
-      result = observing_thread(block, 0.5, 0.1) do
-        print "\r\e[90m#{message}... #{spinner.next} \e[0m"
-      end
-      puts "\r\e[90m#{message}... OK\e[0m"
-      result
-    rescue StandardError
-      puts "\r\e[90m#{message}...\e[0m \e[31mFAILED\e[0m"
-      raise
-    end
-
-    # Given a two-dimensional Array of strings representing a table of data,
-    # translate each row into a single string by joining the values with
-    # whitespace such that all the columns are nicely aligned.
-    #
-    # If a block is given, map the rows through the block first. These two
-    # usages are equivalent:
-    #
-    #   tableize(rows.map(&something))
-    #   tableize(rows, &something)
-    #
-    # Returns a one-dimensional Array of strings, each representing a formatted
-    # row of the resulting table.
-    #
-    def tableize(rows, &block)
-      rows = rows.map(&block) if block
-      widths = max_length_of_each_column(rows)
-      rows.map do |row|
-        row.zip(widths).map { |value, width| value.ljust(width) }.join(" ")
-      end
-    end
-
-    private
-
-    def max_length_of_each_column(rows)
-      Array.new(rows.first.count) do |i|
-        rows.map { |values| values[i].to_s.length }.max
-      end
-    end
-
-    # Starts the `callable` in a background thread and waits for it to complete.
-    # If the callable fails with an exception, it will be raised here. Otherwise
-    # the main thread is paused for an `initial_wait` time in seconds, and
-    # subsequently for `periodic_wait` repeatedly until the thread completes.
-    # After each wait, `yield` is called to allow a block to execute.
-    def observing_thread(callable, initial_wait, periodic_wait)
-      thread = Thread.new(&callable)
-      thread.report_on_exception = false
-      wait_for_exit(thread, initial_wait)
-      loop do
-        break if wait_for_exit(thread, periodic_wait)
-
-        yield
-      end
-      thread.value
-    end
-
-    def wait_for_exit(thread, seconds)
-      thread.join(seconds)
-    rescue StandardError
-      # Sanity check. If we get an exception, the thread should be dead.
-      raise if thread.alive?
-
-      thread
-    end
-  end
-end

data/lib/bundleup/gem_status.rb

@@ -1,59 +0,0 @@
-# rubocop:disable Metrics/BlockLength
-module Bundleup
-  GemStatus = Struct.new(:name,
-                         :old_version,
-                         :new_version,
-                         :newest_version,
-                         :pin) do
-    def pinned?
-      !pin.nil?
-    end
-
-    def upgraded?
-      new_version != old_version
-    end
-
-    def added?
-      old_version.nil?
-    end
-
-    def removed?
-      new_version.nil?
-    end
-
-    def color
-      if major_upgrade? || removed?
-        :red
-      elsif minor_upgrade?
-        :yellow
-      elsif added?
-        :blue
-      else
-        :plain
-      end
-    end
-
-    def major_upgrade?
-      return false if new_version.nil? || old_version.nil?
-
-      major(new_version) != major(old_version)
-    end
-
-    def minor_upgrade?
-      return false if new_version.nil? || old_version.nil?
-
-      !major_upgrade? && minor(new_version) != minor(old_version)
-    end
-
-    private
-
-    def major(version)
-      version.split(".", 2)[0]
-    end
-
-    def minor(version)
-      version.split(".", 3)[1]
-    end
-  end
-end
-# rubocop:enable Metrics/BlockLength

data/lib/bundleup/outdated_parser.rb

@@ -1,17 +0,0 @@
-module Bundleup
-  module OutdatedParser
-    def self.parse(output)
-      expr = if output.match?(/^Gem\s+Current\s+Latest/)
-               # Bundler >= 2.2 format
-               /^(\S+)\s\s+\S+\s\s+(\d\S+)\s\s+(\S.*?)(?:$|\s\s)/
-             else
-               # Bundler < 2.2
-               /\* (\S+) \(newest (\S+),.* requested (.*)\)/
-             end
-
-      output.scan(expr).map do |name, newest, pin|
-        { name: name, newest: newest, pin: pin }
-      end
-    end
-  end
-end

data/lib/bundleup/upgrade.rb

@@ -1,60 +0,0 @@
-module Bundleup
-  class Upgrade
-    def initialize(update_args=[], commands=BundleCommands.new)
-      @update_args = update_args
-      @commands = commands
-      @gem_statuses = {}
-      @original_lockfile_contents = IO.read(lockfile)
-      run
-    end
-
-    def upgrades
-      @gem_statuses.values.select(&:upgraded?).sort_by(&:name)
-    end
-
-    def pins
-      @gem_statuses.values.select(&:pinned?).sort_by(&:name)
-    end
-
-    def lockfile_changed?
-      IO.read(lockfile) != original_lockfile_contents
-    end
-
-    def undo
-      IO.write(lockfile, original_lockfile_contents)
-    end
-
-    private
-
-    attr_reader :update_args, :commands, :original_lockfile_contents
-
-    def run
-      commands.check || commands.install
-      find_versions(:old)
-      commands.update(update_args)
-      find_versions(:new)
-      find_pinned_versions
-    end
-
-    def lockfile
-      "Gemfile.lock"
-    end
-
-    def find_pinned_versions
-      OutdatedParser.parse(commands.outdated).each do |gem|
-        gem_status(gem[:name]).newest_version = gem[:newest]
-        gem_status(gem[:name]).pin = gem[:pin]
-      end
-    end
-
-    def find_versions(type)
-      commands.list.scan(/\* (\S+) \((\S+)(?: (\S+))?\)/) do |name, ver, sha|
-        gem_status(name).public_send("#{type}_version=", sha || ver)
-      end
-    end
-
-    def gem_status(name)
-      @gem_statuses[name] ||= GemStatus.new(name)
-    end
-  end
-end