cartage 1.2 → 2.0.rc1

data/bin/cartage

@@ -3,6 +3,6 @@
 git_path = File.expand_path('../../.git', __FILE__)
 $:.unshift(File.expand_path('../../lib', __FILE__)) if File.exist?(git_path)
 
-require 'cartage/command'
+require 'cartage/cli'
 
-exit Cartage.run(ARGV)
+exit Cartage::CLI.run(ARGV)

data/cartage-cli.md

@@ -0,0 +1,137 @@
+# cartage - Manage releaseable packages
+
+Cartage provides a repeatable means to create a package for a server-side
+application that can be used in deployment with a configuration tool like
+Ansible, Chef, Puppet, or Salt.
+
+## Global Options
+
+__`-C`, `--config-file FILE`__
+
+Use the specified Cartage configuration file.
+
+Use the specified configuration file. If not specified, the configuration is
+found relative to the current working directory (assumed to be the project
+root) at one of the following locations:
+
+1.  config/cartage.yml
+2.  cartage.yml
+3.  .cartage.yml
+
+__`--dependency-cache-path PATH`__
+
+The path where vendored dependencies will be cached between builds.
+
+Dependencies for deployable packages are vendored. To reduce network calls and
+build time, Cartage will cache the vendored dependencies in a tarball
+(dependency-cache.tar.bz2) in this path.
+
+__`-n`, `--name NAME`__
+
+The name of the package.
+
+The name of the package is used with the timestamp to create the final package
+name. Defaults to the last part of the repo URL.
+
+__`-r`, `--root-path PATH`__
+
+The package source root path.
+
+Where the package is built from. Defaults to the root of the repository.
+
+__`-t`, `--target PATH`__
+
+The destination of the created package.
+
+Where the final package will be written. Defaults to 'tmp'.
+
+__`--timestamp TIMESTAMP`__
+
+The timestamp used for building the package.
+
+The timestamp is used with the name of the package is used to create the final
+package name.
+
+__`-T`, `--trace`__
+
+Show the backtrace when an error occurs.
+
+__`--disable-dependency-cache`__
+
+Disable the use of vendor dependency caching.
+
+__`-q`, `--[no-]quiet`__
+
+Silence normal output.
+
+__`-v`, `--[no-]verbose`__
+
+Show verbose output.
+
+__`--version`__
+
+Display the program version.
+
+## Commands
+
+### `help COMMAND`
+
+Shows a list of commands or help for one command.
+
+Gets help for the application or its commands. Can also list the commands in a
+way helpful to creating a bash-style completion function.
+
+*__Options__*
+
+__`-c`__
+
+List commands one per line, to assist with shell completion.
+
+### `manifest`
+
+Work with the Manifest.txt file
+
+#### `manifest` Subcommands
+
+##### `manifest cartignore`
+
+Install or update the .cartignore file
+
+*__Options__*
+
+__`--mode MODE`__
+
+Overwrite or merge an existing .cartignore. If specified, must be one of
+`overwrite` or `merge`.
+
+__`-f`, `--force`, `--overwrite`__
+
+Overwrite an existing .cartignore (the same as `--mode overwrite`).
+
+__`-m`, `--merge`__
+
+Merge an existing .cartignore (the same as `--mode merge`).
+
+##### `manifest check`
+
+Check the Manifest.txt file against the current repository. If no command is
+provided, this will run.
+
+##### `manifest generate`, `manifest update`
+
+Generate or update the Manifest.txt file.
+
+##### `manifest show`
+
+Show the files that will be included in the package.
+
+### `pack`, `build`
+
+Create a package with Cartage based on the Manifest.
+
+*__Options__*
+
+__`--skip-check`__
+
+Skip checking the status of the Manifest before attempting to build the
+package.

data/cartage.yml.sample

@@ -1,15 +1,15 @@
 ---
 # The name of the application. Optional, defaults to the basename of the origin
-# Git URL. Overridden with <tt>cartage --name NAME</tt>.
+# repo URL. Overridden with <tt>cartage --name NAME</tt>.
 # ---
 # name: my-application
 
-# The target path for the Cartage package. Optional and defaults to
+# The target path for the Cartage package. Optional, defaults to
 # <tt>./tmp</tt>. Overridden with <tt>cartage --target PATH</tt>.
 # ---
 # target: tmp/cartage
 
-# The root path of the application. Optional, defaults to the top of the Git
+# The root path of the application. Optional, defaults to the top of the
 # repository (<tt>git rev-parse --show-cdup</tt>). Overridden with <tt>cartage
 # --root-path ROOT_PATH</tt>.
 # ---
@@ -22,162 +22,52 @@
 # ---
 # timestamp: not-a-timestamp
 
-# The bundle cache path, where the package’s <tt>vendor-bundle.tar.bz2</tt>
-# will be stored between builds. Optional, defaults to <tt>./tmp</tt>.
-# Overridden with <tt>cartage --bundle-cache BUNDLE_CACHE</tt>.
+# The type of compression to be used. Optional, defaults to 'bzip2'. Must be
+# one of 'bzip2', 'gzip', or 'none'. Overridden with <tt>cartage --compression
+# TYPE</tt>.
+#
+# This affects the compression of both the final package and the dependency
+# cache.
 # ---
-# bundle_cache: tmp/cache
+# compression: gzip
 
-# The groups to exclude from <tt>bundle install</tt>. Optional, defaults to
-# <tt>[ "development", "test"]</tt>. Overridden with <tt>cartage --without
-# group1,group2</tt>.
+# Silence normal output. Optional, defaults false. Overridden with <tt>cartage
+# --quiet</tt>.
 # ---
-# without:
-#   - development
-#   - test
-#   - other
+# quiet: true
 
-# This section is for all plug-in configuration.
-plugins:
-  # This section is for cartage-s3.
-  s3:
-    # The path to the cartage S3 bucket or directory (for another service that
-    # Fog::Storage supports). This has no default and is overridden with
-    # <tt>cartage s3 --path PATH</tt>.
-    # ---
-    # path: cartage-bucket
-
-    # The credentials dictionary passed to Fog::Storage for uploads. Each
-    # provider has different keys. If present, this will dictionary be used in
-    # preference to <tt>cartage s3</tt> flags <tt>--key-id</tt>,
-    # <tt>--secret-key</tt>, and <tt>--region</tt> as those work *only* with
-    # Amazon AWS S3.
-    credentials:
-      # The name of the provider.
-      # ---
-      # provider: AWS
-      # provider: Rackspace
-      # provider: Google
-
-      # The name of the access user. The name of this key varies per provider.
-      # ---
-      # aws_access_key_id: YOUR_AWS_ACCESS_KEY_ID
-      # rackspace_username: RACKSPACE_USERNAME
-      # google_storage_access_key_id: YOUR_SECRET_ACCESS_KEY_ID
-
-      # The authentication key. The name of this key varies per provider.
-      # ---
-      # aws_secret_access_key: YOUR_AWS_SECRET_ACCESS_KEY
-      # rackspace_api_key: RACKSPACE_API_KEY
-      # google_storage_secret_access_key: YOUR_SECRET_ACCESS_KEY
-
-      # Other keys can be provided as needed for the provider. AWS generally
-      # wants to know the +region+, and Rackspace needs to know if you are
-      # using its European datacentre.
-      # ---
-      # region: us-west-2
-      # rackspace_auth_url: lon.auth.api.rackspacecloud.com
-
-  # This section is for cartage-remote. cartage-remote will not work without a
-  # configuration section at this point because remote build scripts tend to be
-  # heavily customized. This may change in the future.
-  remote:
-    # The name of the build server. This field is required and can show up in
-    # two different formats.
-    # ---
-    # server: build@my-build-machine:2222
-    # server:
-    #   user: build
-    #   host: my-build-machine
-    #   port: 2222
-
-    # The SSH key(s) used to connect to the server. Optional, and
-    # cartage-remote will use <tt>~/.ssh/*id_[rd]sa</tt> to find keys if this
-    # is not provided. Three formats are available.
-    #
-    # As a dictionary (first form), the private keys are embedded directly in
-    # the configuration file. As a string or an array, provides glob patterns
-    # to find key files on disk.
-    # ---
-    # keys:
-    #   custom: |
-    #     -----BEGIN RSA PRIVATE KEY-----
-    #     ...
-    #     -----END RSA PRIVATE KEY-----
-    # keys:
-    #   - "config/secrets/*id_[rd]sa"
-    #   - "~/.ssh/*id_[rd]sa"
-    # keys: "config/secrets/*id_[rd]sa"
+# Show verbose output. Optional, defaults false. Overridden with <tt>cartage
+# --verbose</tt>.
+# ---
+# verbose: true
 
-    # The build script that will be run on the remote server. This is optional
-    # with a reasonable default.
-    #
-    #   #!/bin/bash
-    #   set -e
-    #   if [ -f Gemfile ]; then
-    #     bundle install --path %<remote_bundle>s
-    #     bundle exec cartage build \
-    #       --config-file %<config_file>s \
-    #       --target %<project_path>s
-    #   else
-    #     cartage build --config-file %<config_file>s \
-    #       --target %<project_path>s
-    #   fi
-    # ---
-    # build: |
-    #   #!/bin/bash
-    #   set -e
-    #   if [ -f Gemfile ]; then
-    #     bundle install --path %<remote_bundle>s
-    #     bundle exec cartage s3 \
-    #       --config-file %<config_file>s \
-    #       --target %<project_path>s \
-    #       --verbose
-    #   else
-    #     cartage build \
-    #       --config-file %<config_file>s \
-    #       --target %<project_path>s \
-    #       --verbose
-    #   fi
+# Disable dependency caching. Optional, defaults false.
+# ---
+# disable_dependency_cache: true
+
+# The path where the dependency cache will be written
+# (<tt>dependency-cache.tar.*</tt>) for use in successive builds. Optional,
+# defaults to <tt>./tmp</tt>. Overridden with <tt>cartage
+# --dependency-cache-path PATH</tt>.
+#
+# On a CI system, this should be written somewhere that the CI system uses for
+# build caching.
+# ---
+# dependency_cache_path: <%= ENV['SEMAPHORE_CACHE'] %>
 
-    # The prebuild script that will be run on the local system. This is
-    # optional with a reasonable default.
-    #
-    #   #!/bin/bash
-    #   ssh-keyscan -H %<remote_host>s >> ~/.ssh/known_hosts
-    # ---
-    # prebuild: |
-    #   #!/bin/bash
-    #   ssh-keyscan -H %<remote_host>s >> ~/.ssh/known_hosts
-    #   echo 'Prebuild complete'
+# This dictionary is for command-specific configuration. As of this writing,
+# none of the commands provided by default or in existing plug-ins have
+# command-specific configuration. The keys are freeform and should be based on
+# the *primary* name of the command (so the <tt>cartage pack</tt> command
+# should use the key <tt>pack</tt>.)
+commands: {}
 
-    # The postbuild script that will be run on the local system. This is
-    # optional with no default (no post-build actions).
-    #
-    # This script will be passed the stage identifier as $1 (valid values are
-    # config, ssh_config, prebuild, remote_clone, remote_build, cleanup, or
-    # finished). If the build was interrupted with an error, the error
-    # message will be passed as $2.
-    # ---
-    # postbuild: |
-    #   #!/bin/bash
-    #   case ${1:-undefined} in
-    #     finished)
-    #       t="token=SLACK_TOKEN"
-    #       c="channel=%23ci"
-    #       d=MYDOMAIN
-    #       u="https://${d}.slack.com/services/hooks/slackbot?${t}&${c}"
-    #       curl --data "Build %<name>s-%<timestamp>s complete." ${u}
-    #       ;;
-    #     *)
-    #       : # ${1} is the stage, ${2} is the error message
-    #       ;;
-    #   esac
+# This dictionary is for plug-in-specific configuration. See each plug-in for
+# configuration options. The keys to the plug-ins are based on the plug-in
+# name. cartage-bundler is available as Cartage::Bundler; the transformed
+# plug-in name will be <tt>bundler</tt>.
+plugins: {}
 
 # This must not be indented for it to work.
-<% if File.exist?('config/ansible/cartage.yml') %>
-<%= File.read('config/ansible/cartage.yml') %>
-<% end %>
-<% if File.exist?('config/local/cartage.yml') %>
-<%= File.read('config/local/cartage.yml') %>
-<% end %>
+<%= Cartage::Config.import 'config/ansible/cartage.yml' %>
+<%= Cartage::Config.import 'config/local/cartage.yml' %>

data/lib/cartage.rb

@@ -1,31 +1,22 @@
-require 'pathname'
+# frozen_string_literal: true
 
-# Cartage, a package builder.
-class Cartage
-  VERSION = '1.2' #:nodoc:
-
-  # Plug-in commands that want to return a specific exit code should use
-  # Cartage::StatusError to wrap the error.
-  class StatusError < StandardError
-    # Initialize the exception with +exitstatus+ and the exception to wrap.
-    def initialize(exitstatus, exception_or_message)
-      super(exception_or_message) if exception_or_message
-      @exitstatus = exitstatus
-    end
+require 'pathname'
+require 'json'
 
-    # The exit status to be returned from this exception.
-    attr_reader :exitstatus
-  end
+require 'cartage/core'
+require 'cartage/plugin'
+require 'cartage/config'
 
-  # Plug-in commands that want to return a non-zero exit code without a message
-  # should raise Cartage::QuietError.new(exitstatus).
-  class QuietError < StatusError
-    # Initialize the exception with +exitstatus+.
-    def initialize(exitstatus)
-      super(exitstatus, nil)
-    end
+##
+# Cartage, a reliable package builder.
+class Cartage
+  VERSION = '2.0.rc1' #:nodoc:
 
-    attr_reader :exitstatus
+  # Creates a new Cartage instance. If provided a Cartage::Config object in
+  # +config+, sets the configuration and resolves it. If +config+ is not
+  # provided, the default configuration will be loaded.
+  def initialize(config = nil)
+    self.config = config || Cartage::Config.load(:default)
   end
 
   ##
@@ -39,6 +30,8 @@ class Cartage
   # The default name of the package to be created, derived from the
   # repository's Git URL.
 
+  attr_accessor_with_default :name, default: -> { File.basename(repo_url, '.git') }
+
   ##
   # :attr_accessor: root_path
   #
@@ -50,6 +43,16 @@ class Cartage
   # The default root path of the package, the top-level path of the Git
   # repository.
 
+  attr_reader_with_default :root_path do
+    Pathname(%x(git rev-parse --show-cdup).chomp).expand_path
+  end
+
+  ##
+  def root_path=(v) #:nodoc:
+    reset_computed_values
+    @root_path = Pathname(v).expand_path
+  end
+
   ##
   # :attr_accessor: target
   #
@@ -60,6 +63,10 @@ class Cartage
   #
   # The default target of the package, './tmp'.
 
+  attr_accessor_with_default :target,
+    transform: ->(v) { Pathname(v) },
+    default: -> { Pathname('tmp') }
+
   ##
   # :attr_accessor: timestamp
   #
@@ -70,169 +77,265 @@ class Cartage
   #
   # The default timestamp.
 
-  ##
-  # :attr_accessor: without_groups
-  #
-  # The environments to exclude from a bundle install.
+  attr_accessor_with_default :timestamp, default: -> {
+    Time.now.utc.strftime('%Y%m%d%H%M%S')
+  }
 
   ##
-  # :method: default_without_environments
+  # :attr_accessor: compression
   #
-  # The default environments to exclude from a bundle install. The default is
-  # <tt>[ 'test', 'development' ]</tt>.
+  # The compression to be applied to any tarballs created (either the final
+  # tarball or the dependency cache tarball).
 
-  # Commands that normally output data will have that output suppressed.
-  attr_accessor :quiet
+  ##
+  def compression
+    unless defined?(@compression)
+      @compression = :bzip2
+      reset_computed_values
+    end
+    @compression
+  end
 
-  # Commands will be run with extra information.
-  attr_accessor :verbose
+  ##
+  def compression=(value) #:nodoc:
+    case value
+    when :bzip2, :none, :gzip, 'bzip2', 'none', 'gzip'
+      @compression = value
+      reset_computed_values
+    else
+      fail ArgumentError, "Invalid compression type #{value.inspect}"
+    end
+  end
 
-  # The environment to be used when resolving configuration options from a
-  # configuration file. Cartage configuration files do not usually have
-  # environment partitions, but if they do, use this to select the environment
-  # partition.
-  attr_accessor :environment
+  # If +true+, dependencies will not be cached.
+  attr_accessor :disable_dependency_cache
 
-  # The Config object. If +with_environment+ is +true+ (the default) and
-  # #environment has been set, only the subset of the config matching
-  # #environment will be returned. If +with_environment+ is +false+, the full
-  # configuration will be returned.
+  ##
+  # :attr_reader: dependency_cache
   #
-  # If +for_plugin+ is specified, only the subset of the config for the named
-  # plug-in will be returned.
+  # The path to the tarball of vendored dependencies in the working path.
   #
-  #     # Assume that #environment is 'development'.
-  #     cartage.config
-  #       # => base_config[:development]
-  #     cartage.config(with_environment: false)
-  #       # => base_config
-  #     cartage.config(for_plugin: 's3')
-  #       # => base_config[:development][:plugins][:s3]
-  #     cartage.config(for_plugin: 's3', with_environment: false)
-  #       # => base_config[:plugins][:s3]
-  def config(with_environment: true, for_plugin: nil)
-    env  = environment.to_sym if with_environment && environment
-    plug = for_plugin.to_sym if for_plugin
-
-    cfg = if env
-            base_config[env]
-          else
-            base_config
-          end
-
-    cfg = cfg.plugins[plug] if plug && cfg.plugins
-    cfg
-  end
-
-  # The configuration file to read. This should not be used by clients.
-  attr_writer :load_config #:nodoc:
-
-  # The base config file. This should not be used by clients.
-  attr_accessor :base_config #:nodoc:
-
-  def initialize #:nodoc:
-    @load_config = :default
-  end
-
-  # Create the package.
-  def pack
-    timestamp # Force the timestamp to be set now.
-    prepare_work_area
-    save_release_hashref
-    fetch_bundler
-    install_vendor_bundle
-    restore_modified_files
-    build_final_tarball
+  # Vendored dependencies vary by build system. With Ruby and Bundler, this
+  # would be the <tt>vendor/bundle</tt> path; with npm, this would be the
+  # <tt>node_modules</tt> path.
+
+  ##
+  def dependency_cache
+    self.dependency_cache_path = tmp_path unless defined?(@dependency_cache)
+    @dependency_cache
   end
 
-  # Set or return the bundle cache. The bundle cache is a compressed tarball of
-  # <tt>vendor/bundle</tt> in the working path.
+  ##
+  # :attr_accessor: dependency_cache_path
   #
-  # If it exists, it will be extracted into <tt>vendor/bundle</tt> before
-  # <tt>bundle install --deployment</tt> is run, and it will be created after
-  # the bundle has been installed. In this way, bundle installation works
-  # almost the same way as Capistrano’s shared bundle concept as long as the
-  # path to the bundle_cache has been set to a stable location.
+  # Reads or sets the vendored dependency cache path. This is where the tarball
+  # of vendored dependencies in the working path will reside.
   #
-  # On Semaphore CI, this should be created relative to
+  # On a CI system, this should be written somewhere that the CI system uses
+  # for build caching. On Semaphore CI, this would be
   # <tt>$SEMAPHORE_CACHE</tt>.
-  #
-  #   cartage pack --bundle-cache $SEMAPHORE_CACHE
-  def bundle_cache(location = nil)
-    if location || !defined?(@bundle_cache)
-      @bundle_cache = Pathname(location || tmp_path).
-        join('vendor-bundle.tar.bz2').expand_path
+
+  ##
+  def dependency_cache_path
+    self.dependency_cache_path = tmp_path unless defined?(@dependency_cache_path)
+    @dependency_cache_path
+  end
+
+  ##
+  def dependency_cache_path=(path) #:nodoc:
+    @dependency_cache_path = Pathname(path || tmp_path).expand_path
+    @dependency_cache = @dependency_cache_path.
+      join("dependency-cache.tar#{tar_compression_extension}")
+  end
+
+  # Commands that normally output data will have that output suppressed.
+  attr_accessor :quiet
+
+  # Commands will be run with extra information.
+  attr_accessor :verbose
+
+  # The cartage configuration object, implemented as a recursive OpenStruct.
+  # This can return just the subset of configuration for a command or plug-in
+  # by providing the +for_plugin+ or +for_command+ parameters.
+  def config(for_plugin: nil, for_command: nil)
+    if for_plugin && for_command
+      fail ArgumentError, 'Cannot get config for plug-in and command together'
+    elsif for_plugin
+      @config.dig(:plugins, for_plugin.to_sym) || OpenStruct.new
+    elsif for_command
+      @config.dig(:commands, for_command.to_sym) || OpenStruct.new
+    else
+      @config
     end
-    @bundle_cache
   end
 
-  # Return the release hashref. If the optional +save_to+ parameter is
-  # provided, the release hashref will be written to the specified file.
-  def release_hashref(save_to: nil)
+  # The config file. This should not be used by clients.
+  def config=(cfg) # :nodoc:
+    fail ArgumentError, 'No config provided' unless cfg
+    @plugins = Plugins.new
+    @config = cfg
+    resolve_config!
+  end
+
+  # The release metadata that will be written for the package.
+  def release_metadata
+    @release_metadata ||= {
+      package: {
+        name: name,
+        repo: {
+          type: 'git', # Hardcoded until we have other support
+          url: repo_url
+        },
+        hashref: release_hashref,
+        timestamp: timestamp
+      }
+    }
+  end
+
+  # Return the release hashref.
+  def release_hashref
     @release_hashref ||= %x(git rev-parse HEAD).chomp
-    File.open(save_to, 'w') { |f| f.write @release_hashref } if save_to
-    @release_hashref
   end
 
   # The repository URL.
   def repo_url
     unless defined? @repo_url
-      origin = %x(git remote show -n origin)
-      match = origin.match(%r{\n\s+Fetch URL: (?<fetch>[^\n]+)})
-      @repo_url = match[:fetch]
+      @repo_url = %x(git remote show -n origin).
+        match(/\n\s+Fetch URL: (?<fetch>[^\n]+)/)[:fetch]
     end
     @repo_url
   end
 
-  # The path to the resulting package.
-  def final_tarball
-    @final_tarball ||= Pathname("#{final_name}.tar.bz2")
+  # The temporary path.
+  def tmp_path
+    @tmp_path ||= root_path.join('tmp')
+  end
+
+  # The working path for the job, in #tmp_path.
+  def work_path
+    @work_path ||= tmp_path.join(name)
   end
 
-  # The path to the resulting release_hashref.
-  def final_release_hashref
-    @final_release_hashref ||=
-      Pathname("#{final_name}-release-hashref.txt")
+  # The final name
+  def final_name
+    @final_name ||= tmp_path.join("#{name}-#{timestamp}")
   end
 
-  # A utility method for Cartage plug-ins to display a message only if verbose
-  # is on. Unless the command implemented by the plug-in is output only, this
-  # should be used.
+  # The path to the resulting release-metadata.json file.
+  def final_release_metadata_json
+    @final_release_metadata_json ||= Pathname("#{final_name}-release-metadata.json")
+  end
+
+  # A utility method for Cartage plug-ins to display a +message+ only if
+  # verbose is on. Unless the command implemented by the plug-in is output
+  # only, this should be used.
   def display(message)
     __display(message)
   end
 
+  # A utility method for Cartage plug-ins to run a +command+ in the shell. Uses
+  # IO.popen.
+  def run(command)
+    display command.join(' ')
+
+    IO.popen(command + [ err: %i(child out) ]) do |io|
+      __display(io.read(128), partial: true, verbose: true) until io.eof?
+    end
+
+    fail StandardError, "Error running '#{command.join(' ')}'" unless $?.success?
+  end
+
+  # Returns the registered plug-ins, once configuration has been resolved.
+  def plugins
+    @plugins ||= Plugins.new
+  end
+
+  # Create the release package(s).
+  #
+  # Requests:
+  # *  +:vendor_dependencies+ (#vendor_dependencies, #path)
+  # *  +:pre_build_package+
+  # *  +:build_package+
+  # *  +:post_build_package+
+  def build_package
+    # Force timestamp to be initialized before anything else. This gives us a
+    # stable timestamp for the process.
+    timestamp
+    # Prepare the work area: copy files from root_path to work_path based on
+    # the resolved Manifest.txt.
+    prepare_work_area
+    # Anything that has been modified locally needs to be reset.
+    restore_modified_files
+    # Save both the final release metadata and the in-package release metadata.
+    save_release_metadata
+    # Vendor the dependencies for the package.
+    vendor_dependencies
+    # Request that supporting plug-ins build the package.
+    request_build_package
+  end
+
+  # Returns the flag to use with +tar+ given the value of +compression+.
+  def tar_compression_flag
+    case compression
+    when :bzip2, 'bzip2', nil
+      'j'
+    when :gzip, 'gzip'
+      'z'
+    when :none, 'none'
+      ''
+    end
+  end
+
+  # Returns the extension to use with +tar+ given the value of +compression+.
+  def tar_compression_extension
+    case compression
+    when :bzip2, 'bzip2', nil
+      '.bz2'
+    when :gzip, 'gzip'
+      '.gz'
+    when :none, 'none'
+      ''
+    end
+  end
+
   private
-  def resolve_config!(*with_plugins)
-    return unless @load_config
-    @base_config = Cartage::Config.load(@load_config)
 
-    cfg = config
-    maybe_assign :target, cfg.target
-    maybe_assign :name, cfg.name
-    maybe_assign :root_path, cfg.root_path
-    maybe_assign :timestamp, cfg.timestamp
-    maybe_assign :without_groups, cfg.without
+  attr_writer :release_hashref
+
+  def resolve_config!
+    fail 'No configuration' unless config
+
+    Cartage::Plugin.load_for(singleton_class)
 
-    bundle_cache(cfg.bundle_cache) unless cfg.bundle_cache.nil? ||
-      cfg.bundle_cache.empty?
+    self.disable_dependency_cache = config.disable_dependency_cache
+    self.quiet = config.quiet
+    self.verbose = config.verbose
 
-    with_plugins.each do |name|
-      next unless respond_to? name
-      plugin = send(name)
+    maybe_assign :name, config.name
+    maybe_assign :target, config.target
+    maybe_assign :root_path, config.root_path
+    maybe_assign :timestamp, config.timestamp
+    maybe_assign :dependency_cache_path, config.dependency_cache_path
+    maybe_assign :release_hashref, config.release_hashref
 
-      next unless plugin
+    Cartage::Plugin.each do |name|
+      next unless respond_to?(name)
+      plugin = send(name) or next
       plugin.send(:resolve_config!, config(for_plugin: name))
+
+      plugins.add plugin
     end
+
+    plugins.freeze
   end
 
   def maybe_assign(name, value)
-    return if value.nil? || value.empty? ||
-      instance_variable_defined?(:"@#{name}")
+    return if value.nil? || (value.respond_to?(:empty?) && value.empty?) ||
+        instance_variable_defined?(:"@#{name}")
     send(:"#{name}=", value)
   end
 
-  def __display(message, partial: false, verbose: verbose())
+  def __display(message, partial: false, verbose: self.verbose)
     return unless verbose && !quiet
 
     if partial
@@ -242,26 +345,21 @@ class Cartage
     end
   end
 
-  def run(command)
-    display command.join(' ')
-
-    IO.popen(command + [ err: [ :child, :out ] ]) do |io|
-      __display(io.read(128), partial: true, verbose: true) until io.eof?
-    end
-
-    unless $?.success?
-      raise StandardError, "Error running '#{command.join(' ')}'"
-    end
+  def reset_computed_values
+    instance_variable_set(:@tmp_path, nil)
+    instance_variable_set(:@final_name, nil)
+    instance_variable_set(:@final_release_metadata_json, nil)
+    instance_variable_set(:@release_metadata, nil)
+    instance_variable_set(:@work_path, nil)
+    self.dependency_cache_path = dependency_cache_path
   end
 
   def prepare_work_area
-    display "Preparing cartage work area..."
+    display 'Preparing cartage work area...'
 
     work_path.rmtree if work_path.exist?
     work_path.mkpath
 
-    xf_status = cf_status = nil
-
     manifest.resolve(root_path) do |file_list|
       tar_cf_cmd = [
         'tar', 'cf', '-', '-C', parent, '-h', '-T', file_list
@@ -276,74 +374,29 @@ class Cartage
           xf.write cf.read
         end
 
-        unless $?.success?
-          raise StandardError, "Error running #{tar_xf_cmd.join(' ')}"
-        end
+        fail StandardError, "Error running #{tar_xf_cmd.join(' ')}" unless $?.success?
       end
 
-      unless $?.success?
-        raise StandardError, "Error running #{tar_cf_cmd.join(' ')}"
-      end
+      fail StandardError, "Error running #{tar_cf_cmd.join(' ')}" unless $?.success?
     end
   end
 
-  def save_release_hashref
-    display 'Saving release hashref...'
-    release_hashref save_to: work_path.join('release_hashref')
-    release_hashref save_to: final_release_hashref
-  end
-
-  def extract_bundle_cache
-    run %W(tar xfj #{bundle_cache} -C #{work_path}) if bundle_cache.exist?
-  end
-
-  def create_bundle_cache
-    run %W(tar cfj #{bundle_cache} -C #{work_path} vendor/bundle)
-  end
-
-  def install_vendor_bundle
-    extract_bundle_cache
-
-    Bundler.with_clean_env do
-      Dir.chdir(work_path) do
-        run %w(bundle install --jobs=4 --deployment --clean --without) +
-          without_groups
-      end
-    end
-
-    create_bundle_cache
+  def save_release_metadata
+    display 'Saving release metadata...'
+    json = JSON.generate(release_metadata)
+    work_path.join('release-metadata.json').write(json)
+    final_release_metadata_json.write(json)
   end
 
   def restore_modified_files
-    %x(git status -s).split($/).map(&:split).map(&:last).each { |file|
-      restore_modified_file file
-    }
-  end
-
-  def fetch_bundler
-    Dir.chdir(work_path) do
-      run %w(gem fetch bundler)
-    end
-  end
-
-  def build_final_tarball
-    run %W(tar cfj #{final_tarball} -C #{tmp_path} #{name})
-  end
-
-  def work_path
-    @work_path ||= tmp_path.join(name)
-  end
-
-  def clean
-    [ work_path ] + final
-  end
-
-  def final
-    [ final_tarball, final_release_hashref ]
-  end
-
-  def parent
-    @parent ||= root_path.parent
+    %x(git status -s).
+      split($/).
+      map(&:split).
+      select { |s, _f| s !~ /\?/ }.
+      map(&:last).
+      each { |file|
+        restore_modified_file file
+      }
   end
 
   def restore_modified_file(filename)
@@ -354,175 +407,52 @@ class Cartage
     IO.popen(command) do |show|
       work_path.join(filename).open('w') { |f|
         f.puts show.read
-        f.puts timestamp
       }
     end
   end
 
-  def tmp_path
-    @tmp_path ||= root_path.join('tmp')
-  end
-
-  def final_name
-    @final_name ||= tmp_path.join("#{name}-#{timestamp}")
-  end
-
-  class << self
-    private
+  def vendor_dependencies
+    extract_dependency_cache
 
-    def lazy_accessor(sym, default: nil, setter: nil, &block)
-      ivar = :"@#{sym}"
-      wsym = :"#{sym}="
-      dsym = :"default_#{sym}"
-
-      if default.nil? && block.nil?
-        raise ArgumentError, "No default provided."
-      end
-
-      if setter && !setter.respond_to?(:call)
-        raise ArgumentError, "setter must be callable"
-      end
-
-      setter ||= ->(v) { v }
-
-      dblk = if default.respond_to?(:call)
-               default
-             elsif default.nil?
-               block
-             else
-               -> { default }
-             end
-
-      define_method(sym) do
-        instance_variable_get(ivar) || send(dsym)
-      end
-
-      define_method(wsym) do |value|
-        instance_variable_set(ivar, setter.call(value || send(dsym)))
-      end
+    plugins.request(:vendor_dependencies)
 
-      define_method(dsym, &dblk)
-    end
+    create_dependency_cache(
+      plugins.request_map(:vendor_dependencies, :path).compact.flatten
+    )
   end
 
-  lazy_accessor :name, default: -> { File.basename(repo_url, '.git') }
-  lazy_accessor :root_path, setter: ->(v) { Pathname(v).expand_path },
-    default: -> { Pathname(%x(git rev-parse --show-cdup).chomp).expand_path }
-  lazy_accessor :target, setter: ->(v) { Pathname(v) },
-    default: -> { Pathname('tmp') }
-  lazy_accessor :timestamp, default: -> {
-    Time.now.utc.strftime("%Y%m%d%H%M%S")
-  }
-  lazy_accessor :without_groups, setter: ->(v) { Array(v) },
-    default: -> { %w(development test) }
-  lazy_accessor :base_config, default: -> { OpenStruct.new }
-end
-
-class << Cartage
-  # Run the Cartage command-line program.
-  def run(args) #:nodoc:
-    require_relative 'cartage/plugin'
-    Cartage::Plugin.load
-    Cartage::Plugin.decorate(Cartage)
-
-    cartage = Cartage.new
-
-    cli = CmdParse::CommandParser.new(handle_exceptions: true)
-    cli.main_options.program_name = 'cartage'
-    cli.main_options.version = Cartage::VERSION.split(/\./)
-    cli.main_options.banner = 'Manage releaseable packages.'
-
-    cli.global_options do |opts|
-      # opts.on('--[no-]quiet', 'Silence normal command output.') { |q|
-      #   cartage.quiet = !!q
-      # }
-      opts.on('--[no-]verbose', 'Show verbose output.') { |v|
-        cartage.verbose = !!v
-      }
-      opts.on(
-        '-E', '--environment [ENVIRONMENT]', <<-desc
-Set the environment to be used when necessary. If an environment name is not
-provided, it will check the values of $RAILS_ENV and RACK_ENV. If neither is
-set, this option is ignored.
-        desc
-      ) { |e| cartage.environment = e || ENV['RAILS_ENV'] || ENV['RACK_ENV'] }
-      opts.on(
-        '-C', '--[no-]config-file load_config', <<-desc
-Configure Cartage from a default configuration file or a specified
-configuration file.
-        desc
-      ) { |c| cartage.load_config = c }
-    end
-
-    cli.add_command(CmdParse::HelpCommand.new)
-    cli.add_command(CmdParse::VersionCommand.new)
-    cli.add_command(Cartage::PackCommand.new(cartage))
-
-    Cartage::Plugin.registered.each do |plugin|
-      if plugin.respond_to?(:commands)
-        Array(plugin.commands).flatten.each do |command|
-          registered_commands << command
-        end
-      end
-    end
+  def extract_dependency_cache
+    return if disable_dependency_cache || !dependency_cache.exist?
+    run %W(tar xf#{tar_compression_flag} #{dependency_cache} -C #{work_path})
+  end
 
-    registered_commands.uniq.each { |cmd| cli.add_command(cmd.new(cartage)) }
-    cli.parse
-    return 0
-  rescue Exception => exception
-    show_message_for exception, for_cartage: cartage
-    return exitstatus_for(exception)
-  end
-
-  # Set options common to anything that builds a package (that is, it calls
-  # Cartage#pack).
-  def common_build_options(opts, cartage)
-    opts.on(
-      '-t', '--target PATH',
-      'The build package will be placed in PATH, which defaults to \'tmp\'.'
-    ) { |t| cartage.target = t }
-    opts.on(
-      '-n', '--name NAME',
-      "Set the package name. Defaults to '#{cartage.default_name}'."
-    ) { |n| cartage.name = n }
-    opts.on(
-      '-r', '--root-path PATH',
-      'Set the root path. Defaults to the repository root.'
-    ) { |r| cartage.root_path = r }
-    opts.on(
-      '--timestamp TIMESTAMP',
-      'The timestamp used for the final package.'
-    ) { |t| cartage.timestamp = t }
-    opts.on(
-      '--bundle-cache PATH',
-      'Set the bundle cache path.'
-    ) { |b| cartage.bundle_cache(b) }
-    opts.on(
-      '--without GROUP1,GROUP2', Array,
-      'Set the groups to be excluded from bundle installation.',
-    ) { |w| cartage.without_environments = w }
+  def create_dependency_cache(paths = [])
+    return if disable_dependency_cache || paths.empty?
+    run [
+      'tar',
+      "cf#{tar_compression_flag}",
+      dependency_cache,
+      '-C',
+      work_path,
+      *paths
+    ].map(&:to_s)
   end
 
-  private
-  def registered_commands
-    @registered_commands ||= []
+  def parent
+    @parent ||= root_path.parent
   end
 
-  def exitstatus_for(exception)
-    if exception.respond_to? :exitstatus
-      exception.exitstatus
-    else
-      2
-    end
+  def realize!
+    repo_url
+    root_path
+    release_hashref
+    timestamp
   end
 
-  def show_message_for(exception, for_cartage: nil)
-    unless exception.kind_of?(Cartage::QuietError)
-      $stderr.puts "Error:\n    " + exception.message
-      if for_cartage && for_cartage.verbose
-        $stderr.puts exception.backtrace.join("\n")
-      end
-    end
+  def request_build_package
+    plugins.request(:pre_build_package)
+    plugins.request(:build_package)
+    plugins.request(:post_build_package)
   end
 end