lapidarist 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 52a3f4f375bdf8923d629d74fbe00ebfb7e7dd84738ff6c8e3977d1be2dbcba0
+  data.tar.gz: f6b6ff542df51de84e710725b8a8d9bc53b9e39d529fb1c4e61cbf6eb4d1c40f
+SHA512:
+  metadata.gz: 3ba56292233a696e78c23d274d8ab85d8ec04c5345d2991e2cbbae7f6b52b3dd08090c90af08eed8f63916676061f87415271dfeb6b2e6da020985cf07890f49
+  data.tar.gz: e09937e6620630a277868e27941fca69d893b3fb2513fa0ca24cbfdb06975c5ed238f33604297e6628d73edeaf3b185faed32ba83f55fef7043f0d255c2d25d3

data/.gitignore

@@ -0,0 +1,13 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status
+
+Gemfile.lock

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.5.0
+before_install: gem install bundler -v 1.16.1

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+git_source(:github) { |repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in lapidarist.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 Mark Gangl
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,39 @@
+# Lapidarist
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/lapidarist`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+TODO: Delete this and the text above, and describe your gem
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'lapidarist'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install lapidarist
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/attack/lapidarist.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "lapidarist"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/exe/lapidarist

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+require "lapidarist"
+
+cli = Lapidarist::CLI.new(ARGV)
+exit cli.run

data/lapidarist.gemspec

@@ -0,0 +1,26 @@
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "lapidarist/version"
+
+Gem::Specification.new do |spec|
+  spec.name        = "lapidarist"
+  spec.version     = Lapidarist::VERSION
+  spec.authors     = ["Mark Gangl"]
+  spec.email       = ["mark@attackcorp.com"]
+
+  spec.summary     = %q{Automatically update ruby gem dependencies.}
+  spec.description = %q{Sit back, relax, and allow Lapidarist to do the heavy lifiting and update your ruby gem dependencies for you.}
+  spec.homepage    = "https://github.com/attack/lapidarist"
+  spec.license     = "MIT"
+
+  spec.files = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(spec)/})
+  end
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.16"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+end

data/lib/lapidarist.rb

@@ -0,0 +1,29 @@
+require 'lapidarist/version'
+require 'open3'
+
+require_relative 'lapidarist/configuration'
+require_relative 'lapidarist/options'
+require_relative 'lapidarist/level'
+require_relative 'lapidarist/gem'
+require_relative 'lapidarist/gems'
+
+require_relative 'lapidarist/logger'
+require_relative 'lapidarist/shell'
+require_relative 'lapidarist/bundle_command'
+require_relative 'lapidarist/git_command'
+require_relative 'lapidarist/test_command'
+require_relative 'lapidarist/update'
+require_relative 'lapidarist/outdated'
+require_relative 'lapidarist/sha'
+
+require_relative 'lapidarist/summary'
+require_relative 'lapidarist/status'
+require_relative 'lapidarist/cli'
+
+module Lapidarist
+  class << self
+    def config
+      @config ||= Lapidarist::Configuration.new
+    end
+  end
+end

data/lib/lapidarist/bundle_command.rb

@@ -0,0 +1,49 @@
+module Lapidarist
+  class BundleCommand
+    def initialize
+      @shell = Shell.new
+      @logger = Logger.new
+    end
+
+    def outdated
+      shell.run('cat Gemfile') if Lapidarist.config.debug
+
+      Enumerator.new do |y|
+        shell.run('bundle outdated --strict') do |std_out_err|
+          while line = std_out_err.gets
+            logger.std_out_err(line, 'bundle outdated')
+            gem = parse_gem_from(line)
+            y.yield(gem) if gem
+          end
+        end
+      end
+    end
+
+    def update(gem, level: MAJOR)
+      shell.run("bundle update #{gem.name} --strict --#{level.to_s}")
+    end
+
+    def version(gem)
+      stdout = shell.run('bundle list', "grep \" #{gem.name} \"")
+      result = stdout.match(/\((?<version>[0-9\.]+)\)/)
+      result[:version] if result
+    end
+
+    private
+
+    attr_reader :shell, :logger
+
+    def parse_gem_from(line)
+      regex = / \* (.*) \(newest (\d[\d\.]*\d)[,\s] installed (\d[\d\.]*\d)[\),\s](.*groups \"(.*)\")?/.match line
+
+      unless regex.nil?
+        Gem.new(
+          name: regex[1],
+          newest_version: regex[2],
+          installed_version: regex[3],
+          groups: Array(regex[5]&.split(',')).map(&:strip)
+        )
+      end
+    end
+  end
+end

data/lib/lapidarist/cli.rb

@@ -0,0 +1,94 @@
+module Lapidarist
+  class CLI
+    def initialize(args)
+      @args = args
+      @git = GitCommand.new
+      @test = TestCommand.new
+      @outdated = Outdated.new
+      @update = Update.new
+      @sha = Sha.new
+
+      @logger = Logger.new
+      @logger.setup
+    end
+
+    def run
+      Options.new(args).parse
+      logger.header('Starting lapidarist')
+      logger.debug("directory: #{Lapidarist.config.directory}", :options)
+      logger.debug("test_script: #{Lapidarist.config.test_script}", :options)
+
+      unless git.clean?
+        logger.footer('stopping, there are uncommitted changes')
+        return 1
+      end
+
+      sha.record_good
+      gems = outdated.run
+
+      status = nil
+      1.step do |attempt|
+        logger.header("Attempt ##{attempt}")
+
+        if gems.outdated.none?
+          logger.footer('stopping, there are no applicable outdated gems')
+          status = Status.new(gems, attempt)
+          break
+        end
+
+        updated_gems = update.run(gems, attempt)
+
+        if sha.new_commit_count.zero?
+          logger.footer('nothing updated, trying again')
+          gems = gems.merge(updated_gems)
+          next
+        end
+
+        logger.header("Testing gem updates")
+        if test.success?
+          logger.footer('test passed, nothing left to do')
+          gems = gems.merge(updated_gems)
+          status = Status.new(gems, attempt)
+          break
+        else
+          logger.footer('test failed, investigating failure')
+        end
+
+        failed_gem =
+          if updated_gems.one?
+            updated_but_failed_gem = updated_gems.first
+            git.reset_hard('HEAD^')
+
+            Gem.from(
+              updated_but_failed_gem,
+              attempt: attempt,
+              status: :failed,
+              updated_version: updated_but_failed_gem.latest_attempt[:version],
+              level: updated_but_failed_gem.latest_attempt[:level]
+            )
+          else
+            failed_gem_name = git.bisect(sha.last_good, test)
+            updated_but_failed_gem = updated_gems.detect { |g| g.name == failed_gem_name }
+            gems = gems.merge(updated_gems.take(sha.new_commit_count))
+            sha.record_good
+
+            Gem.from(
+              updated_but_failed_gem,
+              attempt: attempt,
+              status: :failed,
+              updated_version: updated_but_failed_gem.latest_attempt[:version],
+              level: updated_but_failed_gem.latest_attempt[:level]
+            )
+          end
+        gems = gems.merge(failed_gem)
+      end
+
+      Summary.new(gems, logger).display
+      return status.to_i
+    end
+
+    private
+
+    attr_reader :args, :git, :test, :outdated, :update, :sha, :logger
+  end
+end

data/lib/lapidarist/configuration.rb

@@ -0,0 +1,22 @@
+require 'ostruct'
+
+module Lapidarist
+  class Configuration < OpenStruct
+    def initialize
+      super(
+        directory: Pathname.new('.'),
+        test_script: 'test.sh',
+        all: false,
+        quiet: false,
+        verbosity: 0,
+        commit_flags: '',
+        debug: false,
+        log_path: Pathname.new('./tmp/lapidarist.log'),
+        update_limit: nil,
+        groups: [],
+        version: MAJOR,
+        recursive: false
+      )
+    end
+  end
+end

data/lib/lapidarist/gem.rb

@@ -0,0 +1,137 @@
+module Lapidarist
+  class Gem
+    attr_reader :name, :newest_version, :installed_version, :attempts
+
+    def initialize(name:, newest_version:, installed_version:, groups: [], attempts: {})
+      @name = name
+      @newest_version = newest_version
+      @installed_version = installed_version
+      @groups = groups
+      @attempts = attempts
+    end
+
+    def self.from(gem, attempt: 0, status: nil, reason: nil, updated_version: nil, level: nil)
+      attempts = gem.attempts
+
+      if status
+        attempts = attempts.merge(
+          attempt => {
+            status: status,
+            reason: reason,
+            version: updated_version,
+            level: level
+          }
+        )
+      end
+
+      new(
+        name: gem.name,
+        newest_version: gem.newest_version,
+        installed_version: gem.installed_version,
+        groups: gem.groups,
+        attempts: attempts
+      )
+    end
+
+    def ==(other_gem)
+      current_status == other_gem.current_status &&
+        name == other_gem.name &&
+        installed_version == other_gem.installed_version &&
+        newest_version == other_gem.newest_version &&
+        groups == other_gem.groups
+    end
+
+    def groups
+      @groups.sort
+    end
+
+    def dependency?
+      groups.any?
+    end
+
+    def current_status
+      latest_attempt&.fetch(:status, nil)
+    end
+
+    def current_level
+      latest_attempt&.fetch(:level, nil)
+    end
+
+    def outdated?(recursive: false)
+      current_status.nil? || (recursive && available_update_levels?)
+    end
+
+    def failed?
+      current_status == :failed
+    end
+
+    def skip?
+      current_status == :skipped
+    end
+
+    def updated?
+      current_status == :updated
+    end
+
+    def updated_version
+      updated_attempt&.fetch(:version, nil)
+    end
+
+    def what_changed
+      if version_changed?
+        "#{name} from #{installed_version} to #{updated_version}"
+      else
+        "#{name} dependencies"
+      end
+    end
+
+    def available_update_levels?
+      failed? && current_level > PATCH
+    end
+
+    def next_semver_level
+      if current_level
+        LEVELS.detect { |level| level < current_level }
+      else
+        MAJOR
+      end
+    end
+
+    def log_s
+      [
+        "outdated gem: #{name}",
+        "installed: #{installed_version}",
+        "newest: #{newest_version}",
+        "updated: #{updated_version}"
+      ].join(', ')
+    end
+
+    def to_h
+      {
+        name: name,
+        newest_version: newest_version,
+        installed_version: installed_version,
+        groups: groups,
+        attempts: attempts.to_h
+      }
+    end
+
+    def latest_attempt_number
+      @latest_attempt_number ||= attempts.keys.last
+    end
+
+    def latest_attempt
+      @latest_attempt ||= attempts[latest_attempt_number] || {}
+    end
+
+    private
+
+    def version_changed?
+      updated_version && installed_version != updated_version
+    end
+
+    def updated_attempt
+      @updated_attempt ||= attempts.values.detect { |a| a[:status] == :updated }
+    end
+  end
+end

data/lib/lapidarist/gems.rb

@@ -0,0 +1,47 @@
+module Lapidarist
+  class Gems
+    include Enumerable
+
+    def initialize(gems)
+      @gems = gems
+    end
+
+    def each(&block)
+      gems.sort_by(&:name).each(&block)
+    end
+
+    def outdated
+      entries.select do |gem|
+        if (Lapidarist.config.all || gem.dependency?) && gem.outdated?(recursive: Lapidarist.config.recursive)
+          gem
+        end
+      end
+    end
+
+    def updated
+      entries.select(&:updated?)
+    end
+
+    def skipped
+      entries.select(&:skip?)
+    end
+
+    def failed
+      entries.select(&:failed?)
+    end
+
+    def merge(other_gems)
+      Gems.new(
+        Array(other_gems) + entries.select { |gem| !Array(other_gems).map(&:name).include?(gem.name) }
+      )
+    end
+
+    def attempts
+      entries.map(&:latest_attempt_number).compact.max
+    end
+
+    private
+
+    attr_reader :gems
+  end
+end

data/lib/lapidarist/git_command.rb

@@ -0,0 +1,128 @@
+module Lapidarist
+  class GitCommand
+    def initialize
+      @shell = Shell.new
+      @logger = Logger.new
+    end
+
+    def head
+      shell.run('git rev-parse HEAD')[0].strip
+    end
+
+    def add(*files)
+      shell.run("git add #{files.join(' ')}")
+    end
+
+    def commit(message)
+      shell.run("git commit -m '#{message}' #{Lapidarist.config.commit_flags}".strip, label: 'git commit')
+    end
+
+    def bisect(start_sha, test)
+      logger.header('Starting bisect')
+      bisect_start(start_sha)
+      bisect_run(start_sha, test)
+    end
+
+    def log(sha)
+      shell.run("git log HEAD...#{sha}^ --no-color --oneline", label: 'git log')
+    end
+
+    def reset_hard(ref)
+      shell.run("git reset --hard #{ref}")
+    end
+
+    def clean?
+      shell.run('[ -z "$(git status --porcelain)" ]')[1] == 0
+    end
+
+    def count_commits(start_sha, end_sha)
+      shell.run("git rev-list #{end_sha} ^#{start_sha} --count")[0].to_i
+    end
+
+    private
+
+    attr_reader :shell, :logger
+
+    def bisect_start(sha)
+      shell.run('git bisect start')
+      shell.run('git bisect bad')
+      shell.run("git bisect good #{sha}", label: 'git bisect good')
+    end
+
+    def bisect_run(start_sha, test)
+      failing_gem_name = nil
+
+      shell.run("git bisect run #{test}") do |std_out_err|
+        while line = std_out_err.gets
+          bisect_step = BisectStep.new(line, shell)
+
+          if bisect_step.failure?
+            failing_sha = bisect_step.failing_sha
+            failing_gem_name = bisect_step.failing_gem(failing_sha)
+            logger.info("... found failing gem update: #{failing_gem_name}")
+          end
+
+          if bisect_step.success?
+            bisect_reset
+            rewind_to_last_good_commit(failing_sha)
+          end
+        end
+
+        unless failing_gem_name
+          logger.info("... last commit was failing commit")
+        end
+
+        logger.footer("bisect done")
+      end
+
+      if failing_gem_name && Lapidarist.config.debug
+        log(start_sha)
+      end
+
+      failing_gem_name
+    end
+
+    def bisect_reset
+      shell.run('git bisect reset')
+    end
+
+    def rewind_to_last_good_commit(sha)
+      reset_hard("#{sha}^")
+    end
+  end
+
+  class BisectStep
+    def initialize(line, shell)
+      @line = line
+      @shell = shell
+    end
+
+    def success?
+      line == "bisect run success\n"
+    end
+
+    def failure?
+      !failing_sha.nil?
+    end
+
+    def failing_sha
+      sha_regex = Regexp::new("(.*) is the first bad commit\n").match(line)
+      unless sha_regex.nil?
+        sha_regex[1]
+      end
+    end
+
+    def failing_gem(sha)
+      commit_message = shell.run("git log --format=%s -n 1 #{sha}", label: 'git log')[0]
+
+      sha_regex = Regexp::new('Update (.*) from').match(commit_message)
+      unless sha_regex.nil?
+        sha_regex[1]
+      end
+    end
+
+    private
+
+    attr_reader :shell, :line
+  end
+end

data/lib/lapidarist/level.rb

@@ -0,0 +1,32 @@
+module Lapidarist
+  class Level
+    include Comparable
+
+    attr_reader :index
+
+    def initialize(name:, index:)
+      @name = name
+      @index = index
+    end
+
+    def to_s
+      name.to_s
+    end
+
+    def <=>(other)
+      return 1 if index < other.index
+      return 0 if index == other.index
+      return -1 if index > other.index
+    end
+
+    private
+
+    attr_reader :name
+  end
+
+  MAJOR = Level.new(name: :major, index: 1)
+  MINOR = Level.new(name: :minor, index: 2)
+  PATCH = Level.new(name: :patch, index: 3)
+
+  LEVELS = [MAJOR, MINOR, PATCH].freeze
+end

data/lib/lapidarist/logger.rb

@@ -0,0 +1,76 @@
+module Lapidarist
+  class Logger
+    def header(message)
+      write '', 0
+      write "#{message} ...", 0
+    end
+
+    def smart_header(message)
+      if Lapidarist.config.verbosity > 0
+        header(message)
+      else
+        info(message, 0)
+      end
+    end
+
+    def footer(message)
+      write "... #{message}", 0
+    end
+
+    def info(message, level = 0)
+      write message, level
+    end
+
+    def debug(message, label = nil)
+      return unless Lapidarist.config.debug
+
+      if label
+        puts " DEBUG (#{label}) > #{message}"
+      else
+        puts " DEBUG > #{message}"
+      end
+    end
+
+    def std_out_err(message, command)
+      write "OUT_ERR (#{command}) > #{message.strip}", 2
+    end
+
+    def setup
+      if Lapidarist.config.log_path && !Lapidarist.config.log_path.empty?
+        Open3.capture2("mkdir -p #{Lapidarist.config.log_path.dirname}", chdir: Lapidarist.config.directory)
+        Open3.capture2("touch #{Lapidarist.config.log_path}", chdir: Lapidarist.config.directory)
+        clear_log_file
+      end
+    end
+
+    def summary(message)
+      write_std_out(message, 0)
+      write_log_file(message)
+    end
+
+    private
+
+    def write(message, level)
+      log_line = "#{' ' * level}#{message}"
+
+      write_std_out(log_line, level)
+      write_log_file(log_line)
+    end
+
+    def write_std_out(message, level)
+      if level <= Lapidarist.config.verbosity && !Lapidarist.config.quiet
+        puts message
+      end
+    end
+
+    def clear_log_file
+      Open3.capture2("cp /dev/null #{Lapidarist.config.log_path}", chdir: Lapidarist.config.directory)
+    end
+
+    def write_log_file(message)
+      if Lapidarist.config.log_path && !Lapidarist.config.log_path.empty?
+        Open3.capture2("echo \"#{message}\" >> #{Lapidarist.config.log_path}", chdir: Lapidarist.config.directory)
+      end
+    end
+  end
+end

data/lib/lapidarist/options.rb

@@ -0,0 +1,79 @@
+require 'optparse'
+
+module Lapidarist
+  class Options
+    def initialize(args)
+      @args = args
+    end
+
+    def parse
+      opt_parser = OptionParser.new do |opts|
+        opts.on("-d", "--directory DIRECTORY", "Directory to run Lapidarist from.") do |d|
+          Lapidarist.config.directory = Pathname.new(d)
+        end
+
+        opts.on("-t", "--test TEST_SCRIPT", "Test script given to git bisect.") do |t|
+          Lapidarist.config.test_script = t
+        end
+
+        opts.on("-a", "--all", "Update gems that are sub-dependencies.") do |t|
+          Lapidarist.config.all = true
+        end
+
+        opts.on("-q", "--quiet", "Do not print anything to stdout.") do |t|
+          Lapidarist.config.quiet = true
+        end
+
+        opts.on("-v", "Increase verbosity, repeat for more verbosity.") do |t|
+          Lapidarist.config.verbosity += 1
+        end
+
+        opts.on("-f", "--commit-flags flags", "Append flags to the commit command.") do |t|
+          Lapidarist.config.commit_flags = t
+        end
+
+        opts.on("--debug", "Display debug output.") do |t|
+          Lapidarist.config.debug = true
+        end
+
+        opts.on("-l LOG_PATH", "Path to log file") do |t|
+          Lapidarist.config.log_path = t
+        end
+
+        opts.on("-n NUMBER_OF_GEMS", "Limit the number of gems to be updated.") do |t|
+          Lapidarist.config.update_limit = t.to_i
+        end
+
+        opts.on("--one", "Limit the number of gems to be updated to just one.") do |t|
+          Lapidarist.config.update_limit = 1
+        end
+
+        opts.on("-g GROUP_NAME", "--group GROUP_NAME", "Limit gems to be updated to a specified group(s).") do |g|
+          Lapidarist.config.groups << g
+        end
+
+        opts.on("--major", "Limit updates to major, minor and patch versions (essentially everything).") do |p|
+          Lapidarist.config.version = MAJOR
+        end
+
+        opts.on("--minor", "Limit updates to minor and patch versions.") do |p|
+          Lapidarist.config.version = MINOR
+        end
+
+        opts.on("--patch", "Limit updates to patch versions.") do |p|
+          Lapidarist.config.version = PATCH
+        end
+
+        opts.on("-r", "--recursive", "Try updating a the major version, minor version then patch version.") do |t|
+          Lapidarist.config.recursive = true
+        end
+      end
+
+      opt_parser.parse!(args)
+    end
+
+    private
+
+    attr_reader :args
+  end
+end

data/lib/lapidarist/outdated.rb

@@ -0,0 +1,37 @@
+module Lapidarist
+  class Outdated
+    def initialize
+      @bundle = BundleCommand.new
+      @logger = Logger.new
+    end
+
+    def run
+      logger.header('Detecting outdated gems')
+
+      gems = bundle.outdated.each_with_object([]) do |gem, results|
+        reason = reason_to_skip(gem)
+        if reason.nil?
+          logger.info(" + #{gem.log_s}")
+          results.push Gem.from(gem)
+        else
+          logger.info(" - (#{reason}) #{gem.log_s}")
+          results.push Gem.from(gem, status: :skipped, reason: reason)
+        end
+      end
+
+      Gems.new(gems)
+    end
+
+    private
+
+    attr_reader :bundle, :logger
+
+    def reason_to_skip(gem)
+      if !Lapidarist.config.all && !gem.dependency?
+        :sub_dependency
+      elsif Lapidarist.config.groups.any? && (Lapidarist.config.groups & gem.groups).none?
+        :unmatched_group
+      end
+    end
+  end
+end

data/lib/lapidarist/sha.rb

@@ -0,0 +1,27 @@
+module Lapidarist
+  class Sha
+    def initialize
+      @good_shas = []
+      @git = GitCommand.new
+      @logger = Logger.new
+    end
+
+    def record_good
+      good_sha = git.head
+      logger.debug("good sha: #{good_sha}")
+      @good_shas << good_sha
+    end
+
+    def last_good
+      good_shas.last
+    end
+
+    def new_commit_count
+      git.count_commits(last_good, 'HEAD')
+    end
+
+    private
+
+    attr_reader :good_shas, :git, :logger
+  end
+end

data/lib/lapidarist/shell.rb

@@ -0,0 +1,57 @@
+module Lapidarist
+  class Shell
+    def initialize
+      @logger = Logger.new
+    end
+
+    def run(*commands, label: nil, &block)
+      if commands.one?
+        run_single_command(commands.first, label, &block)
+      else
+        pipe_multiple_commands(*commands, &block)
+      end
+    end
+
+    private
+
+    attr_reader :logger
+
+    def run_single_command(command, label)
+      logger.info "COMMAND > `#{command}`", 1
+
+      if block_given?
+        Open3.popen2e(command, chdir: Lapidarist.config.directory) do |_std_in, std_out_err|
+          yield(std_out_err)
+        end
+      else
+        out_err = []
+
+        status = Open3.popen2e(command, chdir: Lapidarist.config.directory) do |_std_in, std_out_err, wait_thr|
+          while line = std_out_err.gets
+            logger.std_out_err(line, label || command)
+            out_err << line
+          end
+          wait_thr.value
+        end
+
+        logger.info "STATUS > #{status}", 2
+
+        [out_err.join("\n"), status]
+      end
+    end
+
+    def pipe_multiple_commands(*commands)
+      if block_given?
+        Open3.pipeline_r(*commands, chdir: Lapidarist.config.directory) do |std_out, _ts|
+          yield(std_out)
+        end
+      else
+        output = ''
+        Open3.pipeline_r(*commands, chdir: Lapidarist.config.directory) do |std_out, _ts|
+          output = std_out.read
+        end
+        output
+      end
+    end
+  end
+end

data/lib/lapidarist/status.rb

@@ -0,0 +1,16 @@
+module Lapidarist
+  class Status
+    def initialize(gems, attempt)
+      @gems = gems
+      @attempt = attempt
+    end
+
+    def to_i
+      gems.updated.any? || attempt == 1
+    end
+
+    private
+
+    attr_reader :gems, :attempt
+  end
+end

data/lib/lapidarist/summary.rb

@@ -0,0 +1,46 @@
+module Lapidarist
+  class Summary
+    def initialize(gems, logger)
+      @gems = gems
+      @logger = logger
+    end
+
+    def display
+      logger.summary ''
+      logger.summary 'Summary'
+      logger.summary '-'*50
+      logger.summary "#{object_count(gems.updated, 'gem', 'gems')} updated, #{object_count(gems.failed, 'gem', 'gems')} failed and #{object_count(gems.skipped, 'gem', 'gems')} skipped in #{object_count(gems.attempts, 'attempt', 'attempts')}"
+      gems.each do |gem|
+        gem.attempts.each do |i, data|
+          case data[:status]
+          when :updated
+            logger.summary " + updated #{gem.name} from #{gem.installed_version} to #{data[:version]}"
+          when :failed
+            logger.summary " x failed #{gem.name} from #{gem.installed_version} to #{data[:version]}"
+          when :skipped
+            logger.summary " - skipped #{gem.name} (#{data[:reason]})"
+          end
+        end
+      end
+    end
+
+    private
+
+    attr_reader :gems, :logger
+
+    def object_count(objects_or_length, singlular, plural)
+      length =
+        if objects_or_length.respond_to?(:length)
+          objects_or_length.length
+        else
+          objects_or_length
+        end
+
+      if length == 1
+        "1 #{singlular}"
+      else
+        "#{length} #{plural}"
+      end
+    end
+  end
+end

data/lib/lapidarist/test_command.rb

@@ -0,0 +1,23 @@
+module Lapidarist
+  class TestCommand
+    def initialize
+      @shell = Shell.new
+    end
+
+    def run
+      shell.run(to_s)[1]
+    end
+
+    def success?
+      run == 0
+    end
+
+    def to_s
+      Lapidarist.config.test_script
+    end
+
+    private
+
+    attr_reader :shell
+  end
+end

data/lib/lapidarist/update.rb

@@ -0,0 +1,60 @@
+module Lapidarist
+  class Update
+    def initialize
+      @bundle = BundleCommand.new
+      @git = GitCommand.new
+      @logger = Logger.new
+    end
+
+    def run(gems, attempt)
+      before_sha = git.head if Lapidarist.config.debug
+
+      logger.header('Updating outdated gems')
+
+      limit =
+        if Lapidarist.config.update_limit
+          [Lapidarist.config.update_limit - gems.updated.length, 0].max
+        else
+          gems.outdated.length
+        end
+
+      updated_gems = gems.outdated.take(limit).map do |outdated_gem|
+        update_gem(outdated_gem, attempt)
+      end
+
+      git.log(before_sha) if Lapidarist.config.debug
+
+      updated_gems
+    end
+
+    private
+
+    attr_reader :outdated_gems, :bundle, :git, :logger
+
+    def update_gem(outdated_gem, attempt)
+      logger.smart_header "Updating #{outdated_gem.name} from #{outdated_gem.installed_version}"
+
+      available_semver_levels = [Lapidarist.config.version]
+      available_semver_levels << outdated_gem.next_semver_level if Lapidarist.config.recursive
+      semver_level_restriction = available_semver_levels.compact.min
+
+      bundle.update(outdated_gem, level: semver_level_restriction)
+      updated_version = bundle.version(outdated_gem)
+
+      if git.clean?
+        skipped_gem = Gem.from(outdated_gem, attempt: attempt, status: :skipped, reason: :nothing_to_update)
+        logger.footer "nothing to update for #{skipped_gem.name}"
+
+        skipped_gem
+      else
+        updated_gem = Gem.from(outdated_gem, attempt: attempt, status: :updated, updated_version: updated_version, level: semver_level_restriction)
+        logger.footer "updated #{updated_gem.name} to #{updated_gem.updated_version}"
+
+        git.add('Gemfile', 'Gemfile.lock')
+        git.commit("Update #{updated_gem.what_changed}")
+
+        updated_gem
+      end
+    end
+  end
+end

data/lib/lapidarist/version.rb

@@ -0,0 +1,3 @@
+module Lapidarist
+  VERSION = "0.0.1"
+end

metadata

@@ -0,0 +1,117 @@
+--- !ruby/object:Gem::Specification
+name: lapidarist
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Mark Gangl
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2018-08-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: Sit back, relax, and allow Lapidarist to do the heavy lifiting and update
+  your ruby gem dependencies for you.
+email:
+- mark@attackcorp.com
+executables:
+- lapidarist
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- exe/lapidarist
+- lapidarist.gemspec
+- lib/lapidarist.rb
+- lib/lapidarist/bundle_command.rb
+- lib/lapidarist/cli.rb
+- lib/lapidarist/configuration.rb
+- lib/lapidarist/gem.rb
+- lib/lapidarist/gems.rb
+- lib/lapidarist/git_command.rb
+- lib/lapidarist/level.rb
+- lib/lapidarist/logger.rb
+- lib/lapidarist/options.rb
+- lib/lapidarist/outdated.rb
+- lib/lapidarist/sha.rb
+- lib/lapidarist/shell.rb
+- lib/lapidarist/status.rb
+- lib/lapidarist/summary.rb
+- lib/lapidarist/test_command.rb
+- lib/lapidarist/update.rb
+- lib/lapidarist/version.rb
+homepage: https://github.com/attack/lapidarist
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.6
+signing_key: 
+specification_version: 4
+summary: Automatically update ruby gem dependencies.
+test_files: []