bundleup 1.3.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: db5d58970165c2381d963205eae11b610d57f35e9654bee2edff54f2d1ff861f
-  data.tar.gz: 508d1cba2d3ab7c2167b60ec38fd1bf49e0252f614e07fe7cce3ed36de3dc32e
+  metadata.gz: 82ad26069759aeaa4516bb5305da2d0d75a38e1c30d8efd275b3fd09df6f2697
+  data.tar.gz: 1cec30ec08cf62b3332c6b8b6539c4231fbf6b1bc29f2c8a4069b5afff2d0b83
 SHA512:
-  metadata.gz: c8133402453232bfd33b17a9c3c5f903874f92f190063bc84e7f29723514ab5333d791d0ac2e6eb4c8deb75a5d5f734a20cb47d63101a79ff879b8e566c63952
-  data.tar.gz: c508a0e3360b51d537c948e1cd95790fd69ad01d43d86a97976729fea4737a84aa25fedd69513f379c26ba82c0abcea3f71bc3f25ad1e802845b24c81f3deb9e
+  metadata.gz: 388e5e6c1ca95b073319c7cd5954348190c2ff1a2e63836659a966eebc7c4da8583474434c33a979d0f70bc69e02686d8a0c4829fcba4123e25b675665af2ee4
+  data.tar.gz: 651c38cc47925f3bafbbc30b50d777c58dfc2918ca3a1329c182ae38735d6e33fb287cb6ba9096b878c4c137746cdc6baa18726362a02eb036ab7a63db9e77a7

data/README.md

@@ -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
 
@@ -54,7 +54,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,21 @@
 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"
+
+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,26 @@
+module Bundleup
+  class Backup
+    def self.restore_on_error(path)
+      backup = new(path)
+      begin
+        yield(backup)
+      rescue StandardError, Interrupt
+        backup.restore
+        raise
+      end
+    end
+
+    def initialize(path)
+      @path = path
+      @original_contents = IO.read(path)
+    end
+
+    def restore
+      IO.write(path, original_contents)
+    end
+
+    private
+
+    attr_reader :path, :original_contents
+  end
+end

data/lib/bundleup/cli.rb

@@ -1,86 +1,120 @@
+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
+    Error = Class.new(StandardError)
+
+    include Colors
+    extend Forwardable
+    def_delegators :Bundleup, :commands, :logger
+
+    def initialize(args)
+      @args = args
     end
 
-    private
+    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.lock") do |backup|
+        update_report, pin_report = perform_analysis
+
+        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?
 
-    def review_upgrades
-      if upgrades.any?
-        puts "\nThe following gem(s) will be updated:\n\n"
-        print_upgrades_table
-      else
-        ok("Nothing to update.")
+        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
 
-    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')}
 
-    def pins
-      upgrade.pins
-    end
+            #{yellow('Do you want to apply these changes [Yn]?')}
 
-    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
-    end
+        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:
 
-    def print_pins_table
-      rows = tableize(pins) do |g|
-        [g.name, g.new_version, "→", g.newest_version, *pin_reason(g)]
-      end
-      puts rows.join("\n")
+            Note that the following gems are being held back:
+
+            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.
+
+        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')}
+
+      USAGE
+      true
     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]
+    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 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
+
+      logger.clear_line
+
+      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]
     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

@@ -4,14 +4,21 @@ module Bundleup
       @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, hash|
+        comment = inline_comment(gem) || prefix_comment(gem)
+        hash[gem] = comment unless comment.nil?
+      end
     end
 
     private
 
     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

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,34 @@
+require "forwardable"
+
+module Bundleup
+  class Report
+    extend Forwardable
+    def_delegators :rows, :empty?
+
+    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.0.0".freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bundleup
 version: !ruby/object:Gem::Version
-  version: 1.3.0
+  version: 2.0.0
 platform: ruby
 authors:
 - Matt Brictson
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-08-08 00:00:00.000000000 Z
+date: 2020-09-03 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,13 +27,16 @@ 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
 homepage: https://github.com/mattbrictson/bundleup
 licenses:

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