bundle_depot 0.0.3 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a55b38b0f6d97f4ebeaaa598a2a262d0d88b5797
-  data.tar.gz: f7fb75fd3fd2f272c61817429d0b5ac09ee31202
+  metadata.gz: 9be713b4d9ac3679609e14010e93609ba007a147
+  data.tar.gz: d7912052a61da3ac04c079d3f8ebd3ae960a47f2
 SHA512:
-  metadata.gz: 9d6f9c86dfb3e854adeacc54050733ab626888a9a1d504cf7daf138686674456ac24753bcaecb03b07fdfa96d81ff9652dbe95d3b4655daed6c72a9d56a398fa
-  data.tar.gz: 746b346998225e6dea7215365e56f797df61187ba2eef2bbed5cf42756dc95c54e3d93eb5e9aa0cdf418df800c441ebfefd80ced575990daec958f46de5d989e
+  metadata.gz: 5e4115c9b586fb36382a7cd1a5869c1fb821f916d1d9b2fd37eaf168d382f7d6f19df66bb6426d4a66cf93979c04b18bde72c7c5355a7f7127c6a72ffa8d0c94
+  data.tar.gz: 75565c28483a91a1ad04fee040e0c60b152c883462daf051d1388445684002ecf94a61e2989b1e4bec7376ad05465dc45e2edf6c86889b66c5bf391f2c369430

data/Gemfile.lock

@@ -1,7 +1,8 @@
 PATH
   remote: .
   specs:
-    bundle_depot (0.0.3)
+    bundle_depot (0.2.0)
+      net-scp
       thor
 
 GEM
@@ -30,6 +31,9 @@ GEM
       multi_json (~> 1.3)
     multi_json (1.8.2)
     multi_test (0.0.2)
+    net-scp (1.1.2)
+      net-ssh (>= 2.6.5)
+    net-ssh (2.7.0)
     rack (1.5.2)
     rack-protection (1.5.1)
       rack

data/README.md

@@ -1,24 +1,101 @@
 # BundleDepot
 
-TODO: Write a gem description
+Utility for caching bundled gems. 
 
-## Installation
+Especially useful for CI servers that rely on clean build directories, or use
+multiple build directories and need to run `bundle install` repeatedly.
 
-Add this line to your application's Gemfile:
 
-    gem 'bundle_depot'
+## How it works
 
-And then execute:
+    bundle-depot fetch
+    bundle install --path .bundle/depot/current
+    bundle-depot store 
 
-    $ bundle
+This will:
 
-Or install it yourself as:
+  1. Create a SHA2 hash from the project's `Gemfile.lock` (e.g. 314ff159)
+  2. If required, a folder `.bundle/depot/cache/314ff159` is created. This is the local cache.
+  3. A remote location is checked for a file `314ff159.tar.gz`. If available it is downloaded and unpacked.
+  4. A symlink is managed to point from `.bundle/depot/current` to `.bundle/depot/cache/314ff159`
+  5. `bundle install` is installing gems when both caches are cold. Otherwise, does nothing \o/
+  6. Tar and zip `.bundle/depot/cache/314ff159` into `.bundle/depot/cache/314ff159.tar.gz`
+  7. Upload `314ff159.tar.gz` to the remote cache
+
+Whenever the Gemfile changes in subsequent runs this process will repeat
+itself. `.bundle/depot/current` will point to the cache entry that contains the
+most recent bundle gems.
+
+
+## Shared Cache on the local machine
+
+This can be used to setup a shared cache on the same machine by configuring the
+environent variable `BUNDLE_DEPOT_CACHE`.
+
+    export BUNDLE_DEPOT_CACHE=/var/lib/bundle_depot
+    bundle-depot fetch 
+    bundle install --path .bundle/depot/current
+    bundle-depot store 
+
+Instead of using `.bundle/depot/cache` this will then use `/var/lib/bundle_depot` as
+a shared cache folder.
+
+## Remote Caching 
+
+  When a remote store is configured this sequence will check and update a remote
+  cache location:
+
+    export BUNDLE_DEPOT_SCP_USER=upload
+    export BUNDLE_DEPOT_SCP_PASS=upload
+    export BUNDLE_DEPOT_SCP_HOST=cache.example.com
+
+    bundle-depot fetch 
+    bundle install --path .bundle/depot/current
+    bundle-depot store 
+
+  In addition to checking the local cache on the file system, this will check
+  the existance of a zipped bundle on a remote location. Currently supported is
+  a connection via SCP.
 
-    $ gem install bundle_depot
 
-## Usage
+## Configuration Options
+
+  * `BUNDLE_DEPOT_CACHE` 
+    Point to where you want to keep your local cache. Defaults to `.bundle/depot/cache`
+
+
+## Complete Example
+
+    #!/bin/sh
+    set -o errexit  # abort after the first command that fails
+
+    fmt <<'EOF'
+    ====================================================================================
+      Preparing Build Agent Environment
+    ====================================================================================
+    EOF
+    gem install bundle_depot --install-dir .gems --bindir bin --no-rdoc --no-ri
+
+
+    fmt <<'EOF'
+    ====================================================================================
+      Bundle it! 
+    ====================================================================================
+    EOF
+    export BUNDLE_DEPOT_HOME=/var/lib/bundle_depot
+    export BUNDLE_DEPOT_SCP_USER=upload
+    export BUNDLE_DEPOT_SCP_PASS=upload
+    export BUNDLD_DEPOT_SCP_HOST=cache.example.com
+
+    bin/bundle-depot fetch
+    bundle install --path .bundle/depot/current --frozen
+    bin/bundle-depot store
+
+
+## Installation
+
+    $ gem install bundle_depot
 
-TODO: Write usage instructions here
 
 ## Contributing
 

data/bundle_depot.gemspec

@@ -19,6 +19,7 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_dependency "thor"
+  spec.add_dependency "net-scp"
 
   spec.add_development_dependency "cucumber"
   spec.add_development_dependency "aruba"

data/features/cli.feature

@@ -1,5 +1,11 @@
 @announce
 Feature: CLI
+  Background:
+    Given the following environment variables are set:
+          | variable                  | value               |
+          | BUNDLE_DEPOT_SCP_USER     | upload              | 
+          | BUNDLE_DEPOT_SCP_PASS     | upload              |
+          | BUNDLE_DEPOT_SCP_HOST     | cache.example.com   |
 
   Scenario: Help screen
     When I run `bundle-depot`

data/features/fetch.feature

@@ -9,8 +9,6 @@ Feature: Fetch remotely stored bundle
 
   Scenario: Working directory defaults to ./bundle/depot
     Given there is the project "json" in the current directory
-      And the remote cache contains the packed bundle for "json" 
-      And the local cache does not contain the bundle "json"
      When I run `bundle-depot fetch`
      Then the following directories should exist:
        | .bundle/depot/cache   |  
@@ -18,11 +16,9 @@ Feature: Fetch remotely stored bundle
 
   Scenario: Local Cache can be overwritten by environment 
     Given there is the project "json" in the current directory
-      And the remote cache contains the packed bundle for "json" 
-      And the local cache does not contain the bundle "json"
       And the following environment variables are set:
-          | variable                 | value               |
-          | BUNDLE_DEPOT_CACHE_PATH  | special/depot/cache |
+          | variable                  | value               |
+          | BUNDLE_DEPOT_CACHE        | special/depot/cache |
      When I run `bundle-depot fetch`
     Then the following directories should exist:
           | special/depot/cache/bde95daa2ce7dede336b4367b9e3a0690027bd6f071e0fdcb1b3047cf988963c |  
@@ -37,27 +33,38 @@ Feature: Fetch remotely stored bundle
      When I run `bundle-depot fetch`
      Then the exit status should be 0 
 
-  Scenario: Does nothing if the remote cache does not contain the bundle 
+  Scenario: .bundle/depot/current points to 
     Given there is the project "json" in the current directory
-      And the remote cache does not contain the packed bundle "json"
      When I run `bundle-depot fetch`
-     Then the exit status should be 0 
+     Then the following symlinks should exist:
+       | source                | target                                                                               |
+       | .bundle/depot/current | .bundle/depot/cache/bde95daa2ce7dede336b4367b9e3a0690027bd6f071e0fdcb1b3047cf988963c |
 
-  Scenario: Download the Bundle to local cache 
+  Scenario: Skip remote check if SCP is not setup
     Given there is the project "json" in the current directory
-      And the remote cache contains the packed bundle for "json" 
-      And the local cache does not contain the bundle "json"
      When I run `bundle-depot fetch`
-     Then the exit status should be 0 
-      And the following directories should exist:
-       | .bundle/depot/cache/bde95daa2ce7dede336b4367b9e3a0690027bd6f071e0fdcb1b3047cf988963c |  
+     Then the output should not contain "=> Bundle is not in remote cache"
 
-  Scenario: .bundle/depot/current points to 
+  Scenario: Check remote cache when SCP is setup
     Given there is the project "json" in the current directory
+      And the following environment variables are set:
+          | variable                  | value               |
+          | BUNDLE_DEPOT_SCP_USER     | upload              | 
+          | BUNDLE_DEPOT_SCP_PASS     | upload              |
+          | BUNDLE_DEPOT_SCP_HOST     | cache.example.com   |
       And the remote cache contains the packed bundle for "json" 
       And the local cache does not contain the bundle "json"
      When I run `bundle-depot fetch`
-     Then the following symlinks should exist:
-       | source                | target                                                                               |
-       | .bundle/depot/current | .bundle/depot/cache/bde95daa2ce7dede336b4367b9e3a0690027bd6f071e0fdcb1b3047cf988963c |
+     Then the output should contain "=> Bundle found in remote cache. Downloading!"
 
+  Scenario: Does nothing if the remote cache does not contain the bundle 
+    Given there is the project "json" in the current directory
+      And the following environment variables are set:
+          | variable                  | value               |
+          | BUNDLE_DEPOT_SCP_USER     | upload              | 
+          | BUNDLE_DEPOT_SCP_PASS     | upload              |
+          | BUNDLE_DEPOT_SCP_HOST     | cache.example.com   |
+      And the remote cache does not contain the packed bundle "json"
+      And the local cache does not contain the bundle "json"
+     When I run `bundle-depot fetch`
+     Then the exit status should be 0 

data/features/step_definitions/cli_steps.rb

@@ -7,7 +7,10 @@ When(/^I run `([^`]*)` in a bundler sandbox$/) do |cmd|
     set_env(key, nil)
   end
   run_simple(unescape(cmd), false)
-  restore_env
+
+  %w[RUBYOPT BUNDLE_PATH BUNDLE_BIN_PATH BUNDLE_GEMFILE GEM_HOME GEM_PATH].each do |key|
+    ENV[key] = original_env[key]
+  end
 end
 
 Then(/^bundler did not install gems$/) do

data/features/store.feature

@@ -3,19 +3,39 @@ Feature: Store Local Package Remotely
 
   Scenario: No Gemfile (store)
     Given there is no Gemfile.lock in the current directory
+      And the following environment variables are set:
+        | variable                  | value               |
+        | BUNDLE_DEPOT_SCP_USER     | upload              | 
+        | BUNDLE_DEPOT_SCP_PASS     | upload              |
+        | BUNDLE_DEPOT_SCP_HOST     | cache.example.com   |
      When I run `bundle-depot store`
      Then the output should contain "Couldn't find Gemfile.lock"
      And the exit status should not be 0
 
+  Scenario: No SCP environment configured
+    Given there is the project "json" in the current directory
+     When I run `bundle-depot store`
+     Then the output should contain "Remote cache is not configured. Configured the SCP environment variables to run 'bundle-depot store'"
+     And the exit status should not be 0
+
   Scenario: Does nothing if remote cache contains the bundle
     Given there is the project "json" in the current directory
+      And the following environment variables are set:
+          | variable                  | value               |
+          | BUNDLE_DEPOT_SCP_USER     | upload              | 
+          | BUNDLE_DEPOT_SCP_PASS     | upload              |
+          | BUNDLE_DEPOT_SCP_HOST     | cache.example.com   |
       And the remote cache contains the packed bundle for "json" 
      When I run `bundle-depot store`
      Then the exit status should be 0 
 
   Scenario: Fails if local cache does not contain the bundle 
-    Given an empty file named "Gemfile.lock"
-      And the remote cache does not contain the packed bundle "json"
+    Given there is the project "json" in the current directory
+      And the following environment variables are set:
+          | variable                  | value               |
+          | BUNDLE_DEPOT_SCP_USER     | upload              | 
+          | BUNDLE_DEPOT_SCP_PASS     | upload              |
+          | BUNDLE_DEPOT_SCP_HOST     | cache.example.com   |
       And the local cache does not contain the bundle "json"
      When I run `bundle-depot store`
      Then the output should contain "Couldn't find the cached bundle."
@@ -23,6 +43,11 @@ Feature: Store Local Package Remotely
 
   Scenario: Uploads the Bundle to remote cache 
     Given there is the project "json" in the current directory
+      And the following environment variables are set:
+          | variable                  | value               |
+          | BUNDLE_DEPOT_SCP_USER     | upload              | 
+          | BUNDLE_DEPOT_SCP_PASS     | upload              |
+          | BUNDLE_DEPOT_SCP_HOST     | cache.example.com   |
       And the remote cache does not contain the packed bundle "json"
       And the local cache contains the bundle "json"
      When I run `bundle-depot store`

data/features/support/env.rb

@@ -5,12 +5,14 @@ require 'bundle_depot'
 
 World(RSpec::Matchers)
 
+ENV["TEST"] = "true"
+
 def local_cache_path
-  File.join(BundleDepot::Cache::DEFAULT_BUNDLE_DEPOT_PATH, "cache")
+  BundleDepot::Cache.cache_path
 end
 
 def remote_cache_path
-  File.join(BundleDepot::Cache::DEFAULT_BUNDLE_DEPOT_PATH, "remote")
+  File.join(".bundle", "depot","remote")
 end
 
 def fixture_project_path(project)
@@ -40,3 +42,4 @@ end
 def remote_cache_packed_bundle_path(bundle)
   File.join(remote_cache_path, fixtures_bundle_name(bundle) + ".tar.gz")
 end
+

data/lib/bundle_depot/cache.rb

@@ -1,143 +1,233 @@
 require "digest"
+require "delegate"
+require 'net/scp'
 
 module BundleDepot
   class BundleDepotError     < StandardError; end
+  class GemfileNotFound      < BundleDepotError; end
+  class RemoteConfigurationMissing < BundleDepotError; end
   class BundleNotFound       < BundleDepotError; end
   class RemoteBundleNotFound < BundleNotFound; end
   class LocalBundleNotFound  < BundleNotFound; end
   class ArchivingFailed      < BundleDepotError; end
 
-  class FileSystemStore
+  class Store
+    def cached?(file)
+      raise NotImplementedError
+    end
+
+    def store(file)
+      raise NotImplementedError
+    end
+
+    def fetch(file, dest_dir)
+      raise NotImplementedError
+    end
+
+    def with_packing
+      PackingDecorator.new(self)
+    end
+  end
+
+  class SCPStore < Store
+    attr_reader :host, :user, :password, :path
+    
+    def initialize(host, user, password, path = ".")
+      @host     = host
+      @user     = user
+      @password = password
+      @path     = path
+    end
+
+    def cached?(file)
+      target = File.join(path, File.basename(file))
+      output = "false"
+
+      Net::SSH.start(host, user, { password: password}) do |session|
+        output = session.exec! "test -e #{target} && echo 'true'"
+      end
+
+      output.strip == "true" 
+    end
+
+    def store(file)
+      Net::SSH.start(host, user, { password: password}) do |session|
+        session.exec! "mkdir -p #{path}"
+        session.scp.upload! file, File.join(path, File.basename(file))
+      end
+    end
+
+    def fetch(file, dest_dir)
+      Net::SCP.download!(host, user, File.join(path, file), file, ssh: { password: password })
+    rescue Net::SCP::Error
+      raise BundleNotFound
+    end
+
+  end
+
+  class FileSystemStore < Store
     attr_reader :path
 
+    def cached?(file)
+      File.exists? File.join(path, file)
+    end
+
     def initialize(path)
       @path = path
       FileUtils.mkdir_p(path)
     end
 
+    def store(file)
+      FileUtils.cp_r file, File.join(path, File.basename(file))
+    end
+
+    def fetch(file, dest_dir)
+      FileUtils.cp_r File.join(path, file), dest_dir
+    end
+  end
+
+  class PackingDecorator < SimpleDelegator
+
     def cached?(file)
-      File.exists? File.join(path, file)
+      super(packed_file(file))
     end
 
     def store(file)
-      FileUtils.cp_r file, File.join(path, File.basename(file))
+      working_dir = File.expand_path(File.dirname(file))
+      source      = File.basename(file)
+      target      = packed_file(file)
+
+      raise BundleNotFound unless File.exists? file
+
+      unless File.exist?(target)
+        puts "=> Packing bundle"
+        `tar -C #{working_dir} -czf #{target} #{source}`
+        raise ArchivingFailed unless $?.exitstatus == 0
+      end  
+
+      super(target)
     end
 
     def fetch(file, dest_dir)
-      FileUtils.cp_r File.join(path, file), dest_dir
+      source = packed_file(file)
+      target = File.join(dest_dir, source)
+      
+      super(source, dest_dir)
+      
+      puts "=> Unpacking #{target}"
+      `tar -C #{dest_dir} -xf #{target}`
+      raise ArchivingFailed unless $?.exitstatus == 0
+    end
+
+    def packed_file(file)
+      file + ".tar.gz"
     end
   end
 
   class Cache
-    DEFAULT_BUNDLE_DEPOT_PATH = File.join(".bundle", "depot")
+    DEFAULT_BUNDLE_DEPOT_CURRENT = File.join(".bundle", "depot", "current")
+    DEFAULT_BUNDLE_DEPOT_CACHE   = File.join(".bundle", "depot", "cache")
 
     attr_reader :local, :remote
 
     def initialize(local  = FileSystemStore.new(Cache.cache_path), 
-                   remote = FileSystemStore.new(File.join(Cache.depot_path, "remote")))
+                   remote = FileSystemStore.new(File.join(".bundle", "depot", "remote")).with_packing)
+
+      if remote_configured? && !ENV["TEST"]
+        remote = SCPStore.new(ENV["BUNDLE_DEPOT_SCP_HOST"], 
+                             ENV["BUNDLE_DEPOT_SCP_USER"],
+                             ENV["BUNDLE_DEPOT_SCP_PASS"], "cache").with_packing
+      end
 
       @local  = local
       @remote = remote
     end
 
     def store
-      if remote.cached?(digest + ".tar.gz")
-        puts "=> Bundle is already in remote cache. Skipping upload."
-      else
-        raise BundleNotFound unless local.cached?(digest)
-        pack 
-        upload
-      end
+      setup
+      store_remote
     end
     
     def fetch
+      setup
+      fetch_remote unless fetch_local
+      manage_symlink
+    end
+
+    def fetch_local 
       if local.cached?(digest)
         puts "=> Bundle found in local cache"
+        true
       else
         puts "=> Bundle is not in local cache"
-        if remote.cached?(digest + ".tar.gz") 
-          download
-          unpack
-        else
-          puts "=> Bundle is not in remote cache"
-          FileUtils.mkdir_p(unpacked_bundle)
-        end          
       end
-      link
     end
 
+    def fetch_remote
+      return unless remote_configured?
+
+      if remote.cached?(digest)
+        puts "=> Bundle found in remote cache. Downloading!"
+        remote.fetch(digest, local.path)
+      else
+        puts "=> Bundle is not in remote cache"
+      end
+    end
+
+    def store_remote
+      raise RemoteConfigurationMissing unless remote_configured?
 
-    def self.depot_path
-      ENV["BUNDLE_DEPOT_PATH"] || DEFAULT_BUNDLE_DEPOT_PATH
+      if remote.cached?(digest)
+        puts "=> Bundle is already in remote cache. Skipping upload."
+      else
+        puts "=> Uploading bundle to remote cache"
+        remote.store(File.join(local.path, digest))
+      end
     end
 
     def self.cache_path
-      ENV["BUNDLE_DEPOT_CACHE_PATH"] || File.join(Cache.depot_path, "cache")
+      ENV["BUNDLE_DEPOT_CACHE"] || DEFAULT_BUNDLE_DEPOT_CACHE
     end
 
     def self.current_bundle_path
-      ENV["BUNDLE_DEPOT_CURRENT_PATH"] || File.join(Cache.depot_path, "current")
+      ENV["DEFAULT_BUNDLE_DEPOT_CURRENT"] || DEFAULT_BUNDLE_DEPOT_CURRENT
     end
 
-    private
-
-    def link
-      source = unpacked_bundle
-      target = Cache.current_bundle_path
-
-      if File.exist?(target)
-        if File.symlink?(target)
-          if File.readlink(File.expand_path(target)) == File.expand_path(source)
-            return
-          else
-            File.unlink(target)
-          end
-        else
-          raise "Shit. #{target} is not a symlink. Aborting to not mess stuff up..."
-        end
-      end
-
-      puts "=> Linking #{target} -> #{source}"
-      File.symlink File.expand_path(source), target 
+    def remote_configured?
+      ENV["BUNDLE_DEPOT_SCP_HOST"]
     end
 
-    def pack
-      return if File.exist?(packed_file)
-      puts "=> Packing bundle"
-      
-      `tar -C #{File.expand_path(local.path)} -czf #{packed_file} #{digest}`
-      raise ArchivingFailed unless $?.exitstatus == 0
-    end
+    private
 
-    def unpack
-      `tar -C #{File.expand_path(local.path)} -xf #{packed_file}`
-      raise ArchivingFailed unless $?.exitstatus == 0
+    def setup
+      FileUtils.mkdir_p(File.dirname(Cache.current_bundle_path))
     end
 
-    def upload
-      puts "=> Uploading bundle to remote cache"
-      remote.store(packed_file)
-    end
+    def manage_symlink
+      source = File.join(local.path, digest)
+      target = Cache.current_bundle_path
 
-    def download
-      puts "=> Bundle found in remote cache. Downloading!"
-      remote.fetch(digest + ".tar.gz", local.path)
+      FileUtils.mkdir_p(source) unless File.exists?(source)
+      
+      if remove_outdated_symlink(source, target)
+        puts "=> Linking #{target} -> #{source}"
+        File.symlink File.expand_path(source), target 
+      else
+        puts "=> #{target} is pointing to the right bundle"
+      end
     end
 
-    def packed_file
-      File.expand_path(File.join(local.path, digest + ".tar.gz"))
-    end
+    def remove_outdated_symlink(source, target)
+      return true unless File.exist?(target)
+      raise "#{target} is not a symlink. Aborting to not mess stuff up..." unless File.symlink?(target)
+      return false if File.symlink?(target) && File.readlink(File.expand_path(target)) == File.expand_path(source)
 
-    def unpacked_bundle
-      File.join(local.path, digest)
+      File.unlink(target)
     end
 
     def digest 
-      Digest::SHA2.file(lock_file).hexdigest
-    end
-
-    def lock_file
-      File.expand_path("Gemfile.lock")
+      raise GemfileNotFound unless File.exist?("Gemfile.lock")
+      Digest::SHA2.file("Gemfile.lock").hexdigest
     end
   end
 

data/lib/bundle_depot/cli.rb

@@ -15,12 +15,10 @@ module BundleDepot
       tenderloin bresaola rump pastrami turkey kevin flank.
     D
     def fetch 
-      unless File.exist?("Gemfile.lock")
-        say "Couldn't find Gemfile.lock"
-        exit 1
-      end
-
       BundleDepot::Cache.new.fetch
+    rescue GemfileNotFound
+      say "Couldn't find Gemfile.lock"
+      exit 1
     end
 
     desc "store", "Store bundle to remote location"
@@ -30,22 +28,16 @@ module BundleDepot
       tenderloin bresaola rump pastrami turkey kevin flank.
     D
     def store
-      unless File.exist?("Gemfile.lock")
-        say "Couldn't find Gemfile.lock"
-        exit 1
-      end
-
       BundleDepot::Cache.new.store
-
+    rescue GemfileNotFound
+      say "Couldn't find Gemfile.lock"
+      exit 1
     rescue BundleNotFound
       say "Couldn't find the cached bundle. Please run 'bundle-depot fetch' before calling this command..."
       exit 2
-
-      # Calculate Checksum
-      # Check local cache
-      # Check remote cache
-      #   Pack
-      #   Upload
+    rescue RemoteConfigurationMissing
+      say "Remote cache is not configured. Configured the SCP environment variables to run 'bundle-depot store'"
+      exit 3
     end
   end
 end

data/lib/bundle_depot/version.rb

@@ -1,3 +1,3 @@
 module BundleDepot
-  VERSION = "0.0.3"
+  VERSION = "0.2.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bundle_depot
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.2.0
 platform: ruby
 authors:
 - Michael Schmidt
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-11-06 00:00:00.000000000 Z
+date: 2013-11-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor
@@ -24,6 +24,20 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: net-scp
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: cucumber
   requirement: !ruby/object:Gem::Requirement