dpl 1.10.17.travis.6637.6 → 2.0.0.alpha.1

data/Rakefile

@@ -43,7 +43,7 @@ end
 
 gemspecs = FileList[File.join(top, "dpl-*.gemspec")]
 
-providers = gemspecs.map { |f| /^dpl-(?<provider>.*)\.gemspec$/ =~ File.basename(f) && provider }
+providers = gemspecs.map { |f| /dpl-(?<provider>.*)\.gemspec/ =~ f && provider }
 
 desc "Build dpl gem"
 file "dpl-#{gem_version}.gem" do
@@ -184,7 +184,7 @@ providers.each do |provider|
     logger.info green("Installing dpl-#{provider} gem")
     sh "gem install --no-post-install-message dpl-#{provider}-#{gem_version}.gem"
     logger.info green("Testing dpl-#{provider} loads correctly")
-    ruby "-S dpl --provider=#{provider} --skip-cleanup=true --no-deploy"
+    ruby "-S dpl --provider=#{provider} --stage=init"
   end
 
   desc "Uninstall dpl-#{provider}"

data/bin/dpl

@@ -1,5 +1,9 @@
 #!/usr/bin/env ruby
-$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+$: << File.expand_path('../../lib', __FILE__)
 
-require 'dpl/cli'
-DPL::CLI.run(ARGV)
+$stdout.sync = true
+$stderr.sync = true
+
+require 'dpl'
+
+Dpl::Cli.new.run(ARGV)

data/lib/dpl.rb

@@ -0,0 +1,20 @@
+require 'dpl/cli'
+require 'dpl/ctx'
+require 'dpl/provider'
+require 'dpl/version'
+
+module Dpl
+  class Error < StandardError
+    attr_reader :opts
+
+    def initialize(msg, opts = {})
+      super(msg)
+      @opts = opts
+      set_backtrace(opts[:backtrace]) if backtrace?
+    end
+
+    def backtrace?
+      !!opts[:backtrace]
+    end
+  end
+end

data/lib/dpl/assets/atlas/install

@@ -0,0 +1,19 @@
+if ! command -v atlas-upload &>/dev/null ; then
+  mkdir -p $HOME/bin $HOME/gopath/src
+  export PATH="$HOME/bin:$PATH"
+
+  if ! command -v gimme &>/dev/null ; then
+    curl -sL -o $HOME/bin/gimme https://raw.githubusercontent.com/meatballhat/gimme/master/gimme
+    chmod +x $HOME/bin/gimme
+  fi
+
+  if [ -z $GOPATH ]; then
+    export GOPATH="$HOME/gopath"
+  else
+    export GOPATH="$HOME/gopath:$GOPATH"
+  fi
+  eval "$(gimme 1.6)" &> /dev/null
+
+  go get github.com/hashicorp/atlas-upload-cli
+  cp $HOME/gopath/bin/atlas-upload-cli $HOME/bin/atlas-upload
+fi

data/lib/dpl/assets/dpl/README.erb.md

@@ -0,0 +1,133 @@
+# Dpl [![Build Status](https://travis-ci.com/travis-ci/dpl.svg?branch=master)](https://travis-ci.com/travis-ci/dpl) [![Code Climate](https://codeclimate.com/github/travis-ci/dpl.png)](https://codeclimate.com/github/travis-ci/dpl) [![Coverage Status](https://coveralls.io/repos/travis-ci/dpl/badge.svg?branch=master&service=github&cache=2019-08-09_17:00)](https://coveralls.io/github/travis-ci/dpl?branch=master) [![Gem Version](https://img.shields.io/gem/v/dpl)](http://rubygems.org/gems/dpl) [![Yard Docs](http://img.shields.io/badge/yard-docs-blue.svg)](http://rubydoc.info/github/travis-ci/dpl)
+
+This version of the README documents dpl v2, the next major version of dpl.
+The REAMDE for dpl v1, the version that is currently used in production on
+Travis CI can be found [here](https://github.com/travis-ci/dpl/blob/v1/README.md).
+
+Dpl is command line tool for deploying code, html, packages, or build artifacts
+to various service providers.
+
+It is tightly integrated into Travis CI's [deployment integration](https://docs.travis-ci.com/user/deployment),
+but also used, and recommended by others, such as [GitLab](https://docs.gitlab.com/ee/ci/examples/deployment/).
+
+It is maintained by Travis CI, largely community driven, and it has existed
+since 2013. If you find support your preferred deployment target missing,
+please do not hesitate to get in touch, and we'll help you [add it](#contributing-to-dpl).
+
+## Table of Contents
+
+* [Requirements](#requirements)
+* [Installation](#installation)
+* [Usage](#usage)
+* [Maturity Levels](#maturity-levels)
+* [Supported Providers](#supported-providers)
+* [Contributing to Dpl](#contributing-to-dpl)
+* [Old Issues](#old-issues)
+* [Code of Conduct](#code-of-conduct)
+* [License](#license)
+* [Credits](#credits)
+
+## Requirements
+
+Dpl requires Ruby 2.2 or later.
+
+Depending on the deployment target dpl might require additional runtimes (e.g.
+Go, Node.js, or Python) to be installed. It also might require sudo access in
+order to install a Debian package.
+
+Dpl is generally optimized for usage on Linux systems.
+
+## Installation
+
+Installation:
+
+```
+gem install dpl
+```
+
+## Usage
+
+Dpl is meant and optimized for usage in ephemeral build environments, such
+as Travis CI, or any other CI/CD pipeline.
+
+Dpl is integrated to Travis CI's build configuration and build script compilation
+tooling, so all you need to do is add the proper configuration to your `.travis.yml`
+file. Please refer to [the documentation](https://docs.travis-ci.com/user/deployment)
+for details.
+
+For usage outside of Travis CI dpl can be executed as follows. Please refer to
+the respective [providers](#supported-providers) for details.
+
+```
+dpl [provider] [options]
+```
+
+Dpl can be used locally, e.g. on your development machine, but it might leave
+artifacts that may alter the behaviour of your system. If you encounter this
+behaviour and it presents a serious issue to you then please open an
+[issue](https://github.com/travis-ci/dpl/issues/new).
+
+### Cleaning up the Git working directory
+
+Dpl v1 has cleaned up the Git working directory by default, using `git stash
+--all`. The default for this option has been changed in dpl v2, and users now
+need to opt in to cleaning up any left over artifacts from the build process
+by passing the option `--cleanup`.
+
+The status of the working directory is relevant only to providers that package
+and push it to the respective remote service (e.g. `heroku` when using the
+`api` strategy, package registry providers, etc.). Most providers will either
+push the latest Git commit, or pull code from a remote repository.
+
+## Maturity Levels
+
+In order to communicate the current development status and maturity of dpl's
+support for a particular service the respective provider is marked with one of
+the following maturity levels, according to the given criteria:
+
+* `dev` - the provider is in development (initial level)
+* `alpha` - the provider is fully tested
+* `beta` - the provider has been in alpha for at least a month, and successful real-world production deployments have been observed
+* `stable` - the provider has been in beta for at least two months, and there are no open issues that qualify as critical (such as deployments failing, documented functionality broken, etc)
+
+## Supported Providers
+
+Dpl supports the following providers:
+
+<% providers.each do |key, name| -%>
+  * <%= "[#{name}](##{name.gsub(/\W+/, '-').downcase})" %>
+<% end -%>
+
+<% providers.each do |key, name|%>
+### <%= name %>
+
+```
+<%= help(key) %>
+```
+<% end -%>
+
+<%= File.read('./CONTRIBUTING.md').gsub(/^#/, '##') %>
+
+## Old Issues
+
+If an issue has been left open and untouched for 90 days or more, we
+automatically close them. We do this to ensure that new issues are more easily
+noticeable, and that old issues that have been resolved or are no longer
+relevant are closed. You can read more about this [here](https://blog.travis-ci.com/2018-03-09-closing-old-issues).
+
+## Code of Conduct
+
+Please see [our code of conduct](CODE_OF_CONDUCT.md) for how to interact with
+this project and its community.
+
+## License
+
+Dpl is licensed under the [MIT License](https://github.com/travis-ci/dpl/blob/master/LICENSE).
+
+## Credits
+
+This tool would not exist without your help.
+
+A huge thank you goes out to all of our current and past [contributors](https://github.com/travis-ci/dpl/graphs/contributors):
+
+<%= contributors %>

data/lib/dpl/assets/dpl/git_ssh

@@ -0,0 +1,2 @@
+#!/bin/sh
+exec ssh -o StrictHostKeychecking=no -o CheckHostIP=no -o UserKnownHostsFile=/dev/null -i %s $@

data/lib/dpl/assets/git/detect_private_key

@@ -0,0 +1,8 @@
+#!/bin/sh
+
+for file in $(git ls-files --cached); do
+  if cat $file | head -n 1 | grep 'BEGIN' | grep 'PRIVATE KEY' > /dev/null; then
+    echo "Commit rejected: private key detected in $file."
+    exit 1
+  fi
+done

data/lib/dpl/assets/hephy/filter_log

@@ -0,0 +1,3 @@
+#!/bin/bash
+$@ 2>&1 | sed -E 's/\[[^ ]+ //'
+exit ${PIPESTATUS[0]}

data/lib/dpl/assets/pypi/install

@@ -0,0 +1,4 @@
+#!/bin/bash
+if [ -z ${VIRTUAL_ENV+x} ]; then export PIP_USER=yes; fi &&
+wget -nv -O - https://bootstrap.pypa.io/get-pip.py | python - --no-setuptools --no-wheel &&
+pip install --upgrade --ignore-installed %{setuptools_arg} %{twine_arg} %{wheel_arg}

data/lib/dpl/assets/scalingo/install

@@ -0,0 +1,6 @@
+#!/bin/bash
+curl --remote-name --location https://cli-dl.scalingo.io/release/scalingo_latest_linux_amd64.tar.gz && \
+tar -zxvf scalingo_latest_linux_amd64.tar.gz && \
+mv scalingo_*_linux_amd64/scalingo . && \
+rm scalingo_latest_linux_amd64.tar.gz && \
+rm -r scalingo_*_linux_amd64

data/lib/dpl/cli.rb

@@ -1,66 +1,54 @@
-require 'dpl/error'
-require 'dpl/provider'
+require 'cl'
 
-module DPL
-  class CLI
-    def self.run(*args)
-      new(args).run
+module Dpl
+  class Cli < Cl
+    def self.new(ctx = nil, name = 'dpl')
+      ctx ||= Dpl::Ctx::Bash.new
+      super
     end
 
-    OPTION_PATTERN = /\A--([a-z][a-z_\-]*)(?:=(.+))?\z/
-    attr_accessor :options, :fold_count
-
-    def initialize(*args)
-      options = {}
-      args.flatten.each do |arg|
-        next options.update(arg) if arg.is_a? Hash
-        die("invalid option %p" % arg) unless match = OPTION_PATTERN.match(arg)
-        key = match[1].tr('-', '_').to_sym
-        if options.include? key
-          options[key] = Array(options[key]) << match[2]
-        else
-          options[key] = match[2] || true
-        end
-      end
-
-      self.fold_count = 0
-      self.options    = default_options.merge(options)
+    def run(args)
+      args = untaint(args)
+      args = with_provider_opt(args)
+      super
+    rescue UnknownCmd
+      unknown_provider(args.first)
+    rescue Error => e
+      error(e)
     end
 
-    def run
-      provider = Provider.new(self, options)
-      provider.deploy
-    rescue Error => error
-      options[:debug] ? raise(error) : die(error.message)
+    # Tainting is being used for automatically obfuscating values for secure
+    # options, so we want to untaint all incoming args here.
+    def untaint(args)
+      args.map(&:dup).each(&:untaint)
     end
 
-    def fold(message)
-      self.fold_count += 1
-      print "travis_fold:start:dpl.#{fold_count}\r" if options[:fold]
-      puts "\e[33m#{message}\e[0m"
-      yield
-    ensure
-      print "\ntravis_fold:end:dpl.#{fold_count}\r" if options[:fold]
+    # backwards compatibility for travis-build dpl v1 integration
+    def with_provider_opt(args)
+      return args unless arg = args.detect { |arg| arg.include?('--provider') }
+      args.delete(arg)
+      [arg.split('=').last, *args]
     end
 
-    def default_options
-      {
-        :app      => File.basename(Dir.pwd),
-        :key_name => %x[hostname].strip
-      }
+    def error(e)
+      msg = "\e[31m#{e.message}\e[0m"
+      msg = [msg, *e.backtrace].join("\n") if e.backtrace?
+      abort msg
     end
 
-    def shell(command)
-      system(command)
+    def unknown_provider(name)
+      msg = "\e[31mUnknown provider: #{name}\e[0m"
+      msg << "\nDid you mean: #{suggestions(name).join(', ')}?" if suggestions(name).any?
+      abort msg
     end
 
-    def die(message)
-      $stderr.puts(message)
-      exit 1
+    def suggestions(name)
+      return [] unless defined?(DidYouMean)
+      DidYouMean::SpellChecker.new(dictionary: providers).correct(name)
     end
 
-    def env
-      ENV
+    def providers
+      Cl::Cmd.registry.keys.map(&:to_s)
     end
   end
 end

data/lib/dpl/ctx.rb

@@ -0,0 +1,2 @@
+require 'dpl/ctx/bash'
+require 'dpl/ctx/test'

data/lib/dpl/ctx/bash.rb

@@ -0,0 +1,543 @@
+require 'cl'
+require 'fileutils'
+require 'logger'
+require 'open3'
+require 'tmpdir'
+require 'securerandom'
+require 'dpl/support/version'
+
+module Dpl
+  module Ctx
+    class Bash < Cl::Ctx
+      include FileUtils
+
+      attr_accessor :folds, :stdout, :stderr, :last_out, :last_err
+
+      def initialize(stdout = $stdout, stderr = $stderr)
+        @stdout, @stderr = stdout, stderr
+        @folds = 0
+        super('dpl', abort: false)
+      end
+
+      # Folds any log output from the given block
+      #
+      # Starts a log fold with the given fold message, calls the block, and
+      # closes the fold.
+      #
+      # @param msg [String] the message that will appear on the log fold
+      def fold(msg, &block)
+        self.folds += 1
+        print "travis_fold:start:dpl.#{folds}\r\e[K"
+        time do
+          info "\e[33m#{msg}\e[0m"
+          yield
+        end
+      ensure
+        print "\ntravis_fold:end:dpl.#{folds}\r\e[K"
+      end
+
+      # Times the given block
+      #
+      # Starts a travis time log tag, calls the block, and closes the tag,
+      # including timing information. This makes a timing badge appear on
+      # the surrounding log fold.
+      def time(&block)
+        id = SecureRandom.hex[0, 8]
+        start = Time.now.to_i * (10 ** 9)
+        print "travis_time:start:#{id}\r\e[K"
+        yield
+      ensure
+        finish = Time.now.to_i * (10 ** 9)
+        duration = finish - start
+        print "\ntravis_time:end:#{id}:start=#{start},finish=#{finish},duration=#{duration}\r\e[K"
+      end
+
+      # Outputs a deprecation warning for a given deprecated option key to stderr.
+      #
+      # @param key [Symbol] the deprecated option key
+      # @param msg [String or Symbol] the deprecation message. if given a Symbol this will be wrapped into the string "Please use #{symbol}".
+      def deprecate_opt(key, msg)
+        msg = "please use #{msg}" if msg.is_a?(Symbol)
+        warn "Deprecated option #{key} used (#{msg})."
+      end
+
+      # Outputs an info level message to stdout.
+      def info(*msgs)
+        stdout.puts(*msgs)
+      end
+
+      # Prints an info level message to stdout.
+      #
+      # This method does not append a newline character to the given message,
+      # which usually is not the desired behaviour. The method is intended to
+      # be used if an initial, partial message is supposed to be printed, which
+      # will be completed later (using the method `info`).
+      #
+      # For example:
+      #
+      #   print 'Starting a long running task ...'
+      #   run_long_running_task
+      #   info 'done.'
+      def print(chars)
+        stdout.print(chars)
+      end
+
+      # Outputs an warning message to stderr
+      #
+      # This method is intended to be used for warning messages that are
+      # supposed to show up in the build log, but do not qualify as errors that
+      # would abort the deployment process. The warning will be highlighted as
+      # yellow text. Use sparingly.
+      def warn(*msgs)
+        msgs = msgs.join("\n").lines
+        msgs.each { |msg| stderr.puts("\e[33;1m#{msg}\e[0m") }
+      end
+
+      # Raises an exception, halting the deployment process.
+      #
+      # The calling executable `bin/dpl` will catch the exception, and abort
+      # the ruby process with the given error message.
+      #
+      # This method is intended to be used for all error conditions that
+      # require the deployment process to be aborted.
+      def error(message)
+        raise Error, message
+      end
+
+      # Returns a logger
+      #
+      # Returns a logger instance, with the given log level set. This can be
+      # used to pass to clients that accept a Ruby logger, such as Faraday,
+      # for debugging purposes.
+      #
+      # Use with care.
+      #
+      # @param level [Symbol] the Ruby logger log level
+      def logger(level = :info)
+        logger = Logger.new(stderr)
+        logger.level = Logger.const_get(level.to_s.upcase)
+        logger
+      end
+
+      def validate_runtimes(runtimes)
+        failed = runtimes.reject(&method(:validate_runtime))
+        failed = failed.map { |name, versions| "#{name} (#{versions.join(', ')})" }
+        error "Failed validating runtimes: #{failed.join(', ')}" if failed.any?
+      end
+
+      def validate_runtime(args)
+        name, required = *args
+        info "Validating required runtime version: #{name} (#{required.join(', ')})"
+        version = name == :node_js ? node_version : python_version
+        required.all? { |required| Version.new(version).satisfies?(required) }
+      end
+
+      def apts_get(packages)
+        packages = packages.reject { |name, cmd = name| which(cmd || name) }
+        return unless packages.any?
+        apt_update
+        packages.each { |package, cmd| apt_get(package, cmd || package, update: false) }
+      end
+
+      # Installs an APT package
+      #
+      # Installs the APT package with the given name, unless the command is already
+      # available (as determined by `which [cmd]`.
+      #
+      # @param package [String] the package name
+      # @param cmd [String] an executable installed by the package, defaults to the package name
+      def apt_get(package, cmd = package, opts = {})
+        return if which(cmd)
+        apt_update unless opts[:update].is_a?(FalseClass)
+        shell "sudo apt-get -qq install #{package}", retry: true
+      end
+
+      def apt_update
+        shell 'sudo apt-get update', retry: true
+      end
+
+      # Requires source files from Ruby gems, installing them on demand if required
+      #
+      # Installs the Ruby gems with the given version, if not already installed, and
+      # requires the specified source files from that gem.
+      #
+      # This happens using the bundler/inline API.
+      #
+      # @param gems [Array<String, String, Hash>] Array of gem requirements: gem name, version, and options (`require`: A single path or a list of paths to source files to require from this Ruby gem)
+      #
+      # @see https://bundler.io/v2.0/guides/bundler_in_a_single_file_ruby_script.html
+      def gems_require(gems)
+        # A local Gemfile.lock might interfer with bundler/inline, even though
+        # it should not. Switching to a temporary dir fixes this.
+        Dir.chdir(tmp_dir) do
+          require 'bundler/inline'
+          info "Installing gem dependencies: #{gems.map { |name, version, _| "#{name} #{"(#{version})" if version}".strip }.join(', ')}"
+          env = ENV.to_h
+          # Bundler.reset!
+          # Gem.loaded_specs.clear
+          gemfile do
+            source 'https://rubygems.org'
+            gems.each { |g| gem *g }
+          end
+          # https://github.com/bundler/bundler/issues/7181
+          ENV.replace(env)
+        end
+      end
+
+      # Installs an NPM package
+      #
+      # Installs the NPM package with the given name, unless the command is already
+      # available (as determined by `which [cmd]`.
+      #
+      # @param package [String] the package name
+      # @param cmd [String] an executable installed by the package, defaults to the package name
+      def npm_install(package, cmd = package)
+        shell "npm install -g #{package}", retry: true unless which(cmd)
+      end
+
+      # Installs a Python package
+      #
+      # Installs the Python package with the given name. A previously installed
+      # package is uninstalled before that, but only if `version` was given.
+      #
+      # @param package [String] Package name (required).
+      # @param cmd     [String] Executable command installed by that package (optional, defaults to the package name).
+      # @param version [String] Package version (optional).
+      def pip_install(package, cmd = package, version = nil)
+        ENV['VIRTUAL_ENV'] = File.expand_path('~/dpl_venv')
+        ENV['PATH'] = File.expand_path("~/dpl_venv/bin:#{ENV['PATH']}")
+        shell 'virtualenv --no-site-packages ~/dpl_venv', echo: true
+        shell 'pip install urllib3[secure]'
+        cmd = "pip install #{package}"
+        cmd << pip_version(version) if version
+        shell cmd, retry: true
+      end
+
+      def pip_version(version)
+        version =~ /^\d+/ ? "==#{version}" : version
+      end
+
+      # Generates an SSH key
+      #
+      # @param name [String] the key name
+      # @param file [String] path to the key file
+      def ssh_keygen(name, file)
+        shell %(ssh-keygen -t rsa -N "" -C #{name} -f #{file})
+      end
+
+      # Runs a single shell command
+      #
+      # This the is the central point of executing any shell commands. It allows two
+      # strategies for running commands in subprocesses:
+      #
+      # * Using [Kernel#system](https://ruby-doc.org/core-2.6.3/Kernel.html#method-i-system)
+      #   which is the default strategy, and should be used when possible. The stdout
+      #   and stderr streams will not be captured, but streamed directly to the parent
+      #   process (so any output on these streams appears in the build log as soon as
+      #   possible).
+      #
+      # * Using [Open3.capture3](https://ruby-doc.org/stdlib-2.6.3/libdoc/open3/rdoc/Open3.html#method-c-capture3)
+      #   which captures both stdout and stderr, and does not automatically output it
+      #   to the build log. Implementors can choose to display it after the shell command
+      #   has completed, using the `%{out}` and `%{err}` interpolation variables. Use
+      #   sparingly.
+      #
+      # The method accepts the following options:
+      #
+      # @param  cmd  [String] the shell command to execute
+      # @param  opts [Hash] options
+      #
+      # @option opts [Boolean] :echo    output the command to stdout before running it
+      # @option opts [Boolean] :silence silence all log output by redirecting stdout and stderr to `/dev/null`
+      # @option opts [Boolean] :capture use `Open3.capture3` to capture stdout and stderr
+      # @option opts [String]  :python  wrap the command into Bash code that enforces the given Python version to be used
+      # @option opts [String]  :retry   retries the command 2 more times if it fails
+      # @option opts [String]  :info    message to output to stdout if the command has exited with the exit code 0 (supports the interpolation variable `${out}` for stdout in case it was captured.
+      # @option opts [String]  :assert  error message to be raised if the command has exited with a non-zero exit code (supports the interpolation variable `${out}` for stdout in case it was captured.
+      #
+      # @return [Boolean] whether or not the command was successful (has exited with the exit code 0)
+      def shell(cmd, opts = {})
+        cmd = Cmd.new(nil, cmd, opts) if cmd.is_a?(String)
+        info cmd.msg if cmd.msg?
+        info cmd.echo if cmd.echo?
+
+        @last_out, @last_err, @last_status = retrying(cmd.retry ? 2 : 0) do
+          send(cmd.capture? ? :open3 : :system, cmd.cmd, cmd.opts)
+        end
+
+        info cmd.success % { out: last_out } if success? && cmd.success?
+        error cmd.error % { err: last_err } if failed? && cmd.assert?
+
+        success? && cmd.capture? ? last_out.chomp : @last_status
+      end
+
+      def retrying(max, tries = 0, status = false)
+        loop do
+          tries += 1
+          out, err, status = yield
+          return [out, err, status] if status || tries > max
+        end
+      end
+
+      # Runs a shell command and captures stdout, stderr, and the exit status
+      #
+      # Runs the given command using `Open3.capture3`, which will capture the
+      # stdout and stderr streams, as well as the exit status. I.e. this will
+      # *not* stream log output in real time, but capture the output, and allow
+      # implementors to display it later (using the `%{out}` and `%{err}`
+      # interpolation variables.
+      #
+      # Use sparingly.
+      #
+      # @option chdir [String] directory temporarily to change to before running the command
+      def open3(cmd, opts)
+        opts = [opts[:chdir] ? only(opts, :chdir) : nil].compact
+        out, err, status = Open3.capture3(cmd, *opts)
+        [out, err, status.success?]
+      end
+
+      # Runs a shell command, streaming any stdout or stderr output, and
+      # returning the exit status
+      #
+      # This is the default method for executing shell commands. The stdout and
+      # stderr will not be captured, but streamed directly to the parent process.
+      #
+      # @option chdir [String] directory temporarily to change to before running the command
+      def system(cmd, opts = {})
+        opts = [opts[:chdir] ? only(opts, :chdir) : nil].compact
+        Kernel.system(cmd, *opts)
+        ['', '', last_process_status]
+      end
+
+      # Whether or not the last executed shell command was successful.
+      def success?
+        !!@last_status
+      end
+
+      # Whether or not the last executed shell command has failed.
+      def failed?
+        !success?
+      end
+
+      # Returns the last child process' exit status
+      #
+      # Internal, and not to be used by implementors. $? is a read-only
+      # variable, so we use a method that we can stub during tests.
+      def last_process_status
+        $?.success?
+      end
+
+      # Whether or not the current Ruby process runs with superuser priviledges.
+      def sudo?
+        Process::UID.eid == 0
+      end
+
+      # Returns current repository name
+      #
+      # Uses the environment variable `TRAVIS_REPO_SLUG` if present, or the
+      # current directory's base name.
+      #
+      # Note that this might return an unexpected string outside of the context
+      # of Travis CI build environments if the method is called at a time when
+      # the current working directory has changed.
+      def repo_name
+        ENV['TRAVIS_REPO_SLUG'] ? ENV['TRAVIS_REPO_SLUG'].split('/').last : File.basename(Dir.pwd)
+      end
+
+      # Returns current repository slug
+      #
+      # Uses the environment variable `TRAVIS_REPO_SLUG` if present, or the
+      # last two segmens of the current working directory's path.
+      #
+      # Note that this might return an unexpected string outside of the context
+      # of Travis CI build environments if the method is called at a time when
+      # the current working directory has changed.
+      def repo_slug
+        ENV['TRAVIS_REPO_SLUG'] || Dir.pwd.split('/')[-2, 2].join('/')
+      end
+
+      # Returns the current build directory
+      #
+      # Uses the environment variable `TRAVIS_REPO_SLUG` if present, and
+      # defaults to `.` otherwise.
+      #
+      # Note that this might return an unexpected string outside of the context
+      # of Travis CI build environments if the method is called at a time when
+      # the current working directory has changed.
+      def build_dir
+        ENV['TRAVIS_BUILD_DIR'] || '.'
+      end
+
+      # Returns the current build number
+      #
+      # Returns the value of the environment variable `TRAVIS_BUILD_NUMBER` if
+      # present.
+      def build_number
+        ENV['TRAVIS_BUILD_NUMBER'] || raise('TRAVIS_BUILD_NUMBER not set')
+      end
+
+      # Returns the encoding of the given file, as determined by `file`.
+      def encoding(path)
+        case `file '#{path}'`
+        when /gzip compressed/
+          'gzip'
+        when /compress'd/
+          'compress'
+        when /text/
+          'text'
+        when /data/
+          # shrugs?
+        end
+      end
+
+      # Returns the current branch name
+      def git_branch
+        ENV['TRAVIS_BRANCH'] || git_rev_parse('HEAD')
+      end
+
+      # Returns the message of the commit `git_sha`.
+      def git_commit_msg
+        `git log #{git_sha} -n 1 --pretty=%B`.chomp
+      end
+
+      # Returns the committer name of the commit `git_sha`.
+      def git_author_name
+        `git log #{git_sha} -n 1 --pretty=%an`.chomp
+      end
+
+      # Returns the comitter email of the commit `git_sha`.
+      def git_author_email
+        `git log #{git_sha} -n 1 --pretty=%ae`.chomp
+      end
+
+      # Whether or not the git working directory is dirty
+      def git_dirty?
+        !Kernel.system('git diff --quiet')
+      end
+
+      # Returns the output of `git log`, using the given args.
+      def git_log(args)
+        `git log #{args}`.chomp
+      end
+
+      # Returns the Git log, separated by NULs
+      #
+      # Returns the output of `git ls-files -z`, which separates log entries by
+      # NULs, rather than newline characters.
+      def git_ls_files
+        `git ls-files -z`.split("\x0")
+      end
+
+      # Returns true if the given ref exists remotely
+      def git_ls_remote?(url, ref)
+        Kernel.system("git ls-remote --exit-code #{url} #{ref} > /dev/null 2>&1")
+      end
+
+      # Returns known Git remote URLs
+      def git_remote_urls
+        `git remote -v`.scan(/\t[^\s]+\s/).map(&:strip).uniq
+      end
+
+      # Returns the sha for the given Git ref
+      def git_rev_parse(ref)
+        `git rev-parse #{ref}`.strip
+      end
+
+      # Returns the latest tag name, if any
+      def git_tag
+        `git describe --tags --exact-match 2>/dev/null`.chomp
+      end
+
+      # Returns the current commit sha
+      def git_sha
+        ENV['TRAVIS_COMMIT'] || `git rev-parse HEAD`.chomp
+      end
+
+      # Returns the local machine's hostname
+      def machine_name
+        `hostname`.strip
+      end
+
+      # Returns the current Node.js version
+      def node_version
+        `node -v`.sub(/^v/, '').chomp
+      end
+
+      # Returns the current NPM version
+      def npm_version
+        `npm --version`
+      end
+
+      # Returns the current Node.js version
+      def python_version
+        `python --version 2>&1`.sub(/^Python /, '').chomp
+      end
+
+      # Returns true or false depending if the given command can be found
+      def which(cmd)
+        !`which #{cmd}`.chomp.empty? if cmd
+      end
+
+      # Returns a unique temporary directory name
+      def tmp_dir
+        @tmp_dir ||= Dir.mktmpdir
+      end
+
+      # Returns the size of the given file path
+      def file_size(path)
+        File.size(path)
+      end
+
+      def move_files(paths)
+        paths.each do |path|
+          target = "#{tmp_dir}/#{File.basename(path)}"
+          mv(path, target) if File.exists?(path)
+        end
+      end
+
+      def unmove_files(paths)
+        paths.each do |path|
+          source = "#{tmp_dir}/#{File.basename(path)}"
+          mv(source, path) if File.exists?(source)
+        end
+      end
+
+      def mv(src, dest)
+        Kernel.system("sudo mv #{src} #{dest} 2> /dev/null")
+      end
+
+      # Writes the given content to the given file path
+      def write_file(path, content, chmod = nil)
+        path = File.expand_path(path)
+        FileUtils.mkdir_p(File.dirname(path))
+        File.open(path, 'w+') { |f| f.write(content) }
+        FileUtils.chmod(chmod, path) if chmod
+      end
+
+      # Writes the given machine, login, and password to ~/.netrc
+      def write_netrc(machine, login, password)
+        require 'netrc'
+        netrc = Netrc.read
+        netrc[machine] = [login, password]
+        netrc.save
+      end
+
+      def sleep(sec)
+        Kernel.sleep(sec)
+      end
+
+      def tty?
+        $stdout.isatty
+      end
+
+      # Returns a copy of the given hash, reduced to the given keys
+      def only(hash, *keys)
+        hash.select { |key, _| keys.include?(key) }.to_h
+      end
+
+      def test?
+        false
+      end
+    end
+  end
+end