borg-rb 0.0.1 → 0.0.2

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    YmUyMjY1NWY1ZGQxY2IzMWI0NWY5OGJiZDA4ZWY1NzczM2ZhYzBkZA==
+    MWM1NWU1YWYzZGJmYjE1Y2NiNWU3NjllOTU3MDgyMTdiOTA0NzFlMQ==
   data.tar.gz: !binary |-
-    NjQ2ZjUwN2I1MzU0ZGM3NmViNzFkY2QzNjZjNTMyMGNlMWRkNzQ5MA==
+    ZWVkNGIxM2VlZjE1NGU2YTI1MDNmYjM0NWJlMGExY2U3YTlmZTMxMA==
 !binary "U0hBNTEy":
   metadata.gz: !binary |-
-    MTMxMDRmYTQ1ZWY2ZDk2NTEwMWM5NjhmNzExYjVlOWU0MGEyNmMzZDRhZWU5
-    ZWQ4YTgyMGY3ZTAyZTUwY2Q0ZGJiN2I5N2ZiMGQ5YjE2NWQ2N2U5NTk4N2Fk
-    ODJmZTNlZjhhYTAxMzFmOWI3NmVlMmQ3ZGU0ZjU4MWFjNWE4YzQ=
+    ZTFmNjM3Mjc0MmU2ZDFmOTNhNDY2NzQ3NWY3ZTQ0ODNiMDRjMzdjYjFiYWUx
+    MzBmM2I2MDkyMzI0YTQ0OTZlMGYwOWQ5ODQ3ZTdlM2Y4NjA5YzRjZmE4M2Rk
+    MDYyMmEwZjMxMDQ2YTgzZTJmZTIyNTRjZjdlZTQ1MTlkNjk3OTY=
   data.tar.gz: !binary |-
-    YzBkOTZjZmIyM2NiNGM5NDE2NDA2OGJlMDdiZjc3MmE5NmQyMmQ4Yjk3ODVh
-    NTJmMjQ5ODYxNWI1ZWQzODRjOGJlYTBlNmVjYTA4MDZhMGM3Y2ZhYTgxNjlj
-    MmIwMjA4NDQ5ZjY4MTQ2Yzk5YWIyYmNkNzhhYzk5NGFlNWEwZDg=
+    M2E4OTY5ZmFhMzFlMTYxMjFiZWY2ZmRhNDJlMWFmNmY4NDVmOGRjYjM2ZWFh
+    Mzg2NDBmMDAyZGFlODNmOWU2YmIxOTMyYjMwNjkxYzM2ZTc0MmYwZTdjMzU4
+    ZjBjZGFhMDA4ZjQwMzVmMzA2ODJhMDE2ODc0ODQxNzNkMTRhMWM=

data/.travis.yml

@@ -1,6 +1,12 @@
 language: ruby
 rvm:
   - 1.9.3
-  - jruby-19mode # JRuby in 1.9 mode
-  - rbx-19mode
+  - 2.0.0
+  - ruby-head
+  - jruby-19mode  # JRuby in 1.9 mode
+  - rbx-19mode # Rubinius in 1.9 mode
+matrix:
+  allow_failures:
+    - rvm: ruby-head
+
 script: bundle exec rspec spec

data/CHANGELOG.md

@@ -0,0 +1,11 @@
+## Current (Unreleased)
+
+## 0.0.2 / 3-22-2013
+
+* Fix load problem in Capfile in generated skeleton
+
+
+## 0.0.1 / 3-21-2013
+
+* Created initial project skeleton: application config, multi-stage app config
+* Created initial plugin skeleton for adding recipes

data/README.md

@@ -6,8 +6,8 @@ deployment.
 [![Dependency Status](https://gemnasium.com/B0RG/borg.png)](https://gemnasium.com/B0RG/borg)
 [![Code Climate](https://codeclimate.com/github/B0RG/borg.png)](https://codeclimate.com/github/B0RG/borg)
 
-# Setup
-## Deployer Package
+## Setup
+### Deployer Package
 
 `borgify` Sets up the following structure
 
@@ -18,11 +18,11 @@ my-deployer-package
 |   |   ├── application1.rb
 │   |   └── application2.rb
 |   ├── initilizers
-|   |   ├── initilizer1.rb
-│   |   └── initilizer2.rb
+|   |   ├── initializer1.rb
+│   |   └── initializer2.rb
 |   └── recipies
-|       ├── recipie1.rb
-│       └── recipie2.rb
+|       ├── recipe1.rb
+│       └── recipe2.rb
 ├── Capfile
 ├── Gemfile
 └── Gemfile.lock
@@ -42,18 +42,18 @@ load 'borg'
 
 ```
 
-## Services Package
+### Services Package
 `borgify plugin` Sets up the following structure
 
 ```
 my-service-package
 ├── cap
 |   ├── initilizers
-|   |   ├── initilizer1.rb
-│   |   └── initilizer2.rb
+|   |   ├── initializer1.rb
+│   |   └── initializer2.rb
 |   └── recipies
-|       ├── recipie1.rb
-│       └── recipie2.rb
+|       ├── recipe1.rb
+│       └── recipe2.rb
 ├── my-service-package.gemspec
 ├── Gemfile
 └── Gemfile.lock
@@ -83,3 +83,11 @@ then all the blocks will be run for that application/stage.
 The CLI enforces that all configs be specified at the start. Consider the command `borg app1:stage1 app2 deploy`
 will result in config app1:stage1, all configs for app2 (1 config for each stage, if there is no stage it assumes the app is the only stage)
 to be load and the deploy task be run against all of them.
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/borg.gemspec

@@ -18,10 +18,12 @@ Gem::Specification.new do |s|
   s.test_files    = s.files.grep(%r{^(test|spec|features)/})
   s.require_paths = ["lib"]
 
-  s.add_dependency "capistrano"
+  s.add_dependency "capistrano", "~> 2.14.2"
   s.add_dependency "capistrano_colors"
   s.add_dependency "colored"
   s.add_dependency "term-ansicolor"
 
   s.add_development_dependency "rspec"
+  s.add_development_dependency "childprocess"
+
 end

data/lib/borg/version.rb

@@ -1,3 +1,3 @@
 module Borg
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/skeleton/Capfile

@@ -4,6 +4,7 @@
 # runs on :exit events when ctrl-c is hit
 # set :borg_sigint_triggers_exit, true
 
-load 'borg.rb'
+load "#{Gem::Specification.find_by_name('borg-rb').gem_dir}/lib/borg.rb"
+
 # load any other borg gems here.
 # NOTE: require ends up causing the initializers to be called every time a config is loaded.

data/spec/acceptance/borgify_spec.rb

@@ -0,0 +1,49 @@
+require 'acceptance_spec_helper'
+
+describe "borgify" do
+  include_context "acceptance"
+
+  before do
+    assert_execute("borgify")
+    @workdir = environment.workdir_path
+  end
+
+  it "creates the right files and directories" do
+    # Gemfile
+    gemfile = @workdir.join("Gemfile")
+    expect(gemfile.exist?).to be_true
+    expect(gemfile.read).to match(/^source "https:\/\/rubygems.org"$/)
+    expect(gemfile.read).to match(/borg-rb/)
+
+    # Capfile
+    capfile = @workdir.join("Capfile")
+    expect(capfile.exist?).to be_true
+
+    # lib directory
+    capfile = @workdir.join("lib")
+    expect(capfile.exist?).to be_true
+
+    # cap directory with the subdirectories: applications, initializers, recipes
+    cap_dir = @workdir.join("cap")
+    expect(cap_dir.exist?).to be_true
+    expect(cap_dir.join("applications")).to be_true
+    expect(cap_dir.join("initializers")).to be_true
+    expect(cap_dir.join("recipes")).to be_true
+  end
+end
+
+describe "borgify plugin" do
+  include_context "acceptance"
+
+  before do
+    assert_execute("borgify", "plugin")
+    @workdir = environment.workdir_path
+  end
+
+  it "creates the right files and directories" do
+    # the gemspec
+    directory_name = File.basename(@workdir = environment.workdir_path)
+    gemspec = @workdir = environment.workdir_path.join("#{directory_name}.gemspec")
+    expect(gemspec.exist?).to be_true
+  end
+end

data/spec/acceptance_spec_helper.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+Dir["./spec/support/**/*.rb"].sort.each { |f| require f }
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+
+end

data/spec/spec_helper.rb

@@ -1,3 +1,2 @@
 require 'capistrano/cli'
-
 require 'yaml'

data/spec/support/isolated_environment.rb

@@ -0,0 +1,58 @@
+require "fileutils"
+require "pathname"
+require "childprocess"
+
+module Support
+  # This class creates a temporary directory to act as the working directory
+  #
+  # Modified from: https://github.com/mitchellh/vagrant/blob/master/spec/support/isolated_environment.rb
+  class IsolatedEnvironment
+    ROOT_DIR = Pathname.new(File.expand_path("../../", __FILE__))
+
+    attr_reader :workdir, :workdir_path
+
+    def initialize
+      # Create a temporary directory for our work
+      @workdir = TempDir.new("borg")
+      @workdir_path = Pathname.new(TempDir.new("borg").path)
+      # puts "Initialize isolated environment: #{@workdir_path.to_s}"
+    end
+
+    # Copies a skeleton into this isolated environment. This is useful
+    # for testing environments that require a complex setup.
+    #
+    # @param [String] name Name of the skeleton in the root directory.
+    def skeleton!(name)
+      # Copy all the files into the home directory
+      source = Dir.glob(ROOT_DIR.join(name).join("*").to_s)
+      FileUtils.cp_r(source, @workdir.to_s)
+    end
+
+    # Executes a command in the context of this isolated environment.
+    # Any command executed will therefore see our temporary directory
+    # as the home directory.
+    def execute(command, *argN)
+      # Determine the options
+      options = argN.last.is_a?(Hash) ? argN.pop : {}
+      options = {
+          workdir: @workdir_path,
+          notify: [:stdin, :stderr, :stdout]
+      }.merge(options)
+
+      # Add the options to be passed on
+      argN << options
+
+      # Execute, logging out the stdout/stderr as we get it
+      # puts("Executing: #{[command].concat(argN).inspect}")
+      Support::Subprocess.execute(command, *argN) do |type, data|
+        yield type, data if block_given?
+      end
+    end
+
+    # Closes the environment and cleans it up
+    def close
+      # puts "Removing isolated environment: #{@workdir.path}"
+      FileUtils.rm_rf(@workdir.path)
+    end
+  end
+end

data/spec/support/matchers/succeed.rb

@@ -0,0 +1,14 @@
+# Matcher that verifies that a process succeeds.
+RSpec::Matchers.define :succeed do
+  match do |thing|
+    expect(thing.exit_code).to eq 0
+  end
+
+  failure_message_for_should do |actual|
+    "expected process to succeed. exit code: #{actual.exit_code}"
+  end
+
+  failure_message_for_should_not do |actual|
+    "expected process to fail. exit code: #{actual.exit_code}"
+  end
+end

data/spec/support/platform.rb

@@ -0,0 +1,81 @@
+module Support
+  # This class just contains some platform checking code.
+  # source: https://github.com/mitchellh/vagrant/blob/master/lib/vagrant/util/platform.rb)
+  class Platform
+    class << self
+      def tiger?
+        platform.include?("darwin8")
+      end
+
+      def leopard?
+        platform.include?("darwin9")
+      end
+
+      def cygwin?
+        platform.include?("cygwin")
+      end
+
+      [:darwin, :bsd, :freebsd, :linux, :solaris].each do |type|
+        define_method("#{type}?") do
+          platform.include?(type.to_s)
+        end
+      end
+
+      def windows?
+        %W[mingw mswin].each do |text|
+          return true if platform.include?(text)
+        end
+
+        false
+      end
+
+      # Returns boolean noting whether this is a 64-bit CPU. This
+      # is not 100% accurate and there could easily be false negatives.
+      #
+      # @return [Boolean]
+      def bit64?
+        ["x86_64", "amd64"].include?(RbConfig::CONFIG["host_cpu"])
+      end
+
+      # Returns boolean noting whether this is a 32-bit CPU. This
+      # can easily throw false positives since it relies on {#bit64?}.
+      #
+      # @return [Boolean]
+      def bit32?
+        !bit64?
+      end
+
+      # This takes as input a path as a string and converts it into
+      # a platform-friendly version of the path. This is most important
+      # when using the path in shell environments with Cygwin.
+      #
+      # @param [String] path
+      # @return [String]
+      def platform_path(path)
+        return path if !cygwin?
+
+        process = Subprocess.execute("cygpath", "-u", path.to_s)
+        process.stdout.chomp
+      end
+
+      # Returns a boolean noting whether the terminal supports color.
+      # output.
+      def terminal_supports_colors?
+        if windows?
+          return ENV.has_key?("ANSICON")
+        end
+
+        true
+      end
+
+      def tar_file_options
+        # create, write only, fail if the file exists, binary if windows
+        File::WRONLY | File::EXCL | File::CREAT | (windows? ? File::BINARY : 0)
+      end
+
+      def platform
+        RbConfig::CONFIG["host_os"].downcase
+      end
+    end
+  end
+end

data/spec/support/shared_contexts/acceptance.rb

@@ -0,0 +1,28 @@
+require "support/isolated_environment"
+
+shared_context "acceptance" do
+  # Setup the environment so that we have an isolated area to run our acceptance tests
+  let!(:environment) { Support::IsolatedEnvironment.new }
+
+  after do
+    environment.close
+  end
+
+  # Executes the given command in the context of the isolated environment.
+  #
+  # @return [Object]
+  def execute(*args, &block)
+    environment.execute(*args, &block)
+  end
+
+  # This method is an assertion helper for asserting that a process
+  # succeeds. It is a wrapper around `execute` that asserts that the
+  # exit status was successful.
+  def assert_execute(*args, &block)
+    result = execute(*args, &block)
+    expect(result).to succeed
+    #assert(result.exit_code == 0, "expected '#{args.join(" ")}' to succeed")
+    result
+  end
+
+end

data/spec/support/subprocess.rb

@@ -0,0 +1,259 @@
+require 'childprocess'
+
+module Support
+  # Execute a command in a subprocess, gathering the results and
+  # exit status.
+  #
+  # This class also allows you to read the data as it is outputted
+  # from the subprocess in real time, by simply passing a block to
+  # the execute method.
+  #
+  # Modified from: https://github.com/mitchellh/vagrant/blob/master/lib/vagrant/util/subprocess.rb
+  class Subprocess
+    # The chunk size for reading from subprocess IO.
+    READ_CHUNK_SIZE = 4096
+
+    # Convenience method for executing a method.
+    def self.execute(*command, &block)
+      new(*command).execute(&block)
+    end
+
+    def initialize(*command)
+      @options = command.last.is_a?(Hash) ? command.pop : {}
+      @command = command
+    end
+
+    def execute
+      # Get the timeout, if we have one
+      timeout = @options[:timeout]
+
+      # Get the working directory
+      workdir = @options[:workdir] || Dir.pwd
+
+      # Get what we're interested in being notified about
+      notify  = @options[:notify] || []
+      notify  = [notify] if !notify.is_a?(Array)
+      if notify.empty? && block_given?
+        # If a block is given, subscribers must be given, otherwise the
+        # block is never called. This is usually NOT what you want, so this
+        # is an error.
+        message = "A list of notify subscriptions must be given if a block is given"
+        raise ArgumentError, message
+      end
+
+      # Let's get some more useful booleans that we access a lot so
+      # we're not constantly calling an `include` check
+      notify_table = {}
+      notify_table[:stderr] = notify.include?(:stderr)
+      notify_table[:stdout] = notify.include?(:stdout)
+      notify_stdin  = notify.include?(:stdin)
+
+      # Build the ChildProcess
+      process = ChildProcess.build(*@command)
+
+      # Create the pipes so we can read the output in real time as
+      # we execute the command.
+      stdout, stdout_writer = IO.pipe
+      stderr, stderr_writer = IO.pipe
+      process.io.stdout = stdout_writer
+      process.io.stderr = stderr_writer
+      process.duplex = true
+
+      # Set the environment on the process if we must
+      if @options[:env]
+        @options[:env].each do |k, v|
+          process.environment[k] = v
+        end
+      end
+
+      # Start the process
+      begin
+        Dir.chdir(workdir) do
+          process.start
+        end
+      rescue ChildProcess::LaunchError => ex
+        # Raise our own version of the error so that users of the class
+        # don't need to be aware of ChildProcess
+        raise LaunchError.new(ex.message)
+      end
+
+      # Make sure the stdin does not buffer
+      process.io.stdin.sync = true
+
+      if RUBY_PLATFORM != "java"
+        # On Java, we have to close after. See down the method...
+        # Otherwise, we close the writers right here, since we're
+        # not on the writing side.
+        stdout_writer.close
+        stderr_writer.close
+      end
+
+      # Create a dictionary to store all the output we see.
+      io_data = { :stdout => "", :stderr => "" }
+
+      # Record the start time for timeout purposes
+      start_time = Time.now.to_i
+
+      while true
+        writers = notify_stdin ? [process.io.stdin] : []
+        results = IO.select([stdout, stderr], writers, nil, timeout || 0.1)
+        results ||= []
+        readers = results[0]
+        writers = results[1]
+
+        # Check if we have exceeded our timeout
+        raise TimeoutExceeded, process.pid if timeout && (Time.now.to_i - start_time) > timeout
+
+        # Check the readers to see if they're ready
+        if readers && !readers.empty?
+          readers.each do |r|
+            # Read from the IO object
+            data = read_io(r)
+
+            # We don't need to do anything if the data is empty
+            next if data.empty?
+
+            io_name = r == stdout ? :stdout : :stderr
+
+            io_data[io_name] += data
+            yield io_name, data if block_given? && notify_table[io_name]
+          end
+        end
+
+        # Break out if the process exited. We have to do this before
+        # attempting to write to stdin otherwise we'll get a broken pipe
+        # error.
+        break if process.exited?
+
+        # Check the writers to see if they're ready, and notify any listeners
+        if writers && !writers.empty?
+          yield :stdin, process.io.stdin if block_given?
+        end
+      end
+
+      # Wait for the process to end.
+      begin
+        remaining = (timeout || 32000) - (Time.now.to_i - start_time)
+        remaining = 0 if remaining < 0
+
+        process.poll_for_exit(remaining)
+      rescue ChildProcess::TimeoutError
+        raise TimeoutExceeded, process.pid
+      end
+
+      # Read the final output data, since it is possible we missed a small
+      # amount of text between the time we last read data and when the
+      # process exited.
+      [stdout, stderr].each do |io|
+        # Read the extra data, ignoring if there isn't any
+        extra_data = read_io(io)
+        next if extra_data == ""
+
+        # Log it out and accumulate
+        io_name = io == stdout ? :stdout : :stderr
+        io_data[io_name] += extra_data
+
+        # Yield to any listeners any remaining data
+        yield io_name, extra_data if block_given?
+      end
+
+      if RUBY_PLATFORM == "java"
+        # On JRuby, we need to close the writers after the process,
+        # for some reason. See GH-711.
+        stdout_writer.close
+        stderr_writer.close
+      end
+
+      # Return an exit status container
+      Result.new(process.exit_code, io_data[:stdout], io_data[:stderr])
+    end
+
+    protected
+
+    # Reads data from an IO object while it can, returning the data it reads.
+    # When it encounters a case when it can't read anymore, it returns the
+    # data.
+    #
+    # @return [String]
+    def read_io(io)
+      data = ""
+
+      while true
+        begin
+          if Platform.windows?
+            # Windows doesn't support non-blocking reads on
+            # file descriptors or pipes so we have to get
+            # a bit more creative.
+
+            # Check if data is actually ready on this IO device.
+            # We have to do this since `readpartial` will actually block
+            # until data is available, which can cause blocking forever
+            # in some cases.
+            results = IO.select([io], nil, nil, 0.1)
+            break if !results || results[0].empty?
+
+            # Read!
+            data << io.readpartial(READ_CHUNK_SIZE)
+          else
+            # Do a simple non-blocking read on the IO object
+            data << io.read_nonblock(READ_CHUNK_SIZE)
+          end
+        rescue Exception => e
+          # The catch-all rescue here is to support multiple Ruby versions,
+          # since we use some Ruby 1.9 specific exceptions.
+
+          breakable = false
+          if e.is_a?(EOFError)
+            # An `EOFError` means this IO object is done!
+            breakable = true
+          elsif defined?(IO::WaitReadable) && e.is_a?(IO::WaitReadable)
+            # IO::WaitReadable is only available on Ruby 1.9+
+
+            # An IO::WaitReadable means there may be more IO but this
+            # IO object is not ready to be read from yet. No problem,
+            # we read as much as we can, so we break.
+            breakable = true
+          elsif e.is_a?(Errno::EAGAIN)
+            # Otherwise, we just look for the EAGAIN error which should be
+            # all that IO::WaitReadable does in Ruby 1.9.
+            breakable = true
+          end
+
+          # Break out if we're supposed to. Otherwise re-raise the error
+          # because it is a real problem.
+          break if breakable
+          raise
+        end
+      end
+
+      data
+    end
+
+    # An error which raises when a process fails to start
+    class LaunchError < StandardError; end
+
+    # An error which occurs when the process doesn't end within
+    # the given timeout.
+    class TimeoutExceeded < StandardError
+      attr_reader :pid
+
+      def initialize(pid)
+        super()
+        @pid = pid
+      end
+    end
+
+    # Container class to store the results of executing a subprocess.
+    class Result
+      attr_reader :exit_code
+      attr_reader :stdout
+      attr_reader :stderr
+
+      def initialize(exit_code, stdout, stderr)
+        @exit_code = exit_code
+        @stdout    = stdout
+        @stderr    = stderr
+      end
+    end
+  end
+end

data/spec/support/temp_dir.rb

@@ -0,0 +1,33 @@
+require 'fileutils'
+require 'tempfile'
+
+module Support
+  # This class provides an easy way of creating a temporary
+  # directory and having it removed when the application exits.
+  #
+  # Modified from: https://github.com/mitchellh/vagrant/blob/master/spec/support/tempdir.rb
+  class TempDir
+    attr_reader :path
+
+    def initialize(basename = "borg")
+      @path = Dir.mktmpdir(basename)
+
+      # Setup a finalizer to delete the directory. This is the same way
+      # that Tempfile and friends do this...
+      @cleanup_proc = lambda do
+        FileUtils.rm_rf(@path) if File.directory?(@path)
+      end
+
+      ObjectSpace.define_finalizer(self, @cleanup_proc)
+    end
+
+    # This deletes the temporary directory.
+    def unlink
+      # Delete the directory
+      @cleanup_proc.call
+
+      # Undefine the finalizer since we're all cleaned up
+      ObjectSpace.undefine_finalizer(self)
+    end
+  end
+end

metadata

@@ -1,29 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: borg-rb
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Identified
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-03-21 00:00:00.000000000 Z
+date: 2013-03-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: capistrano
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 2.14.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 2.14.2
 - !ruby/object:Gem::Dependency
   name: capistrano_colors
   requirement: !ruby/object:Gem::Requirement
@@ -80,6 +80,20 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: childprocess
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Ruby-based software provisioning and deployment framework
 email:
 - phil@identified.com
@@ -92,6 +106,7 @@ extra_rdoc_files: []
 files:
 - .gitignore
 - .travis.yml
+- CHANGELOG.md
 - Capfile
 - Gemfile
 - README.md
@@ -119,11 +134,19 @@ files:
 - skeleton/cap/recipies/.gitkeep
 - skeleton/lib/.gitkeep
 - skeleton/mygem.gemspec.skeleton
+- spec/acceptance/borgify_spec.rb
+- spec/acceptance_spec_helper.rb
 - spec/lib/borg/cli/applications_spec.rb
 - spec/lib/borg/configuration/applications_spec.rb
 - spec/lib/borg/configuration/assimilator_spec.rb
 - spec/lib/borg/configuration/stages_spec.rb
 - spec/spec_helper.rb
+- spec/support/isolated_environment.rb
+- spec/support/matchers/succeed.rb
+- spec/support/platform.rb
+- spec/support/shared_contexts/acceptance.rb
+- spec/support/subprocess.rb
+- spec/support/temp_dir.rb
 homepage: https://github.com/B0RG/borg
 licenses:
 - MIT
@@ -149,9 +172,17 @@ signing_key:
 specification_version: 4
 summary: Ruby-based software provisioning and deployment framework
 test_files:
+- spec/acceptance/borgify_spec.rb
+- spec/acceptance_spec_helper.rb
 - spec/lib/borg/cli/applications_spec.rb
 - spec/lib/borg/configuration/applications_spec.rb
 - spec/lib/borg/configuration/assimilator_spec.rb
 - spec/lib/borg/configuration/stages_spec.rb
 - spec/spec_helper.rb
+- spec/support/isolated_environment.rb
+- spec/support/matchers/succeed.rb
+- spec/support/platform.rb
+- spec/support/shared_contexts/acceptance.rb
+- spec/support/subprocess.rb
+- spec/support/temp_dir.rb
 has_rdoc: