capistrano-strategy-copy-bundled 0.6.0 → 0.7.0

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2011 Rudolf Schmidt
+Copyright (c) 2011-2012 Rudolf Schmidt
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -0,0 +1,58 @@
+# Capistrano Strategy: Copy Bundled
+
+This recipe for capistrano utilizes the regular copy strategy. However,
+instead of bundling the gems on the remote servers, they are already
+pre-bundled on the deploy machine and sent as one package.
+
+In some networks, due to security reasons, production servers are not
+allowed to access the internal company network. When that is the case,
+you are not able access your internally written gems. Also, those kind
+of servers usually, and intentionally, have no version control installed
+or are behind a firewall with blocked access to rubygems, github, etc.
+
+This capistrano recipe tries to help out with that.
+
+
+## Installation
+
+System wide usage
+
+```console
+gem install 'capistrano-strategy-copy-bundled'
+```
+
+In your Gemfile
+
+```ruby
+gem 'capistrano-strategy-copy-bundled'
+```
+
+
+## Usage
+
+As this recipe does it's own bundling, there is not need to: `require 'bundler/capistrano'`.
+
+All you have to do in your `config/deploy.rb`:
+
+```ruby
+require 'capistrano-strategy-copy-bundled'
+set :deploy_via,    :copy_bundled           # bundle gems locally and send them packed to all servers
+```
+
+Additionally to that, you can set the usual options when using the regular :copy strategy for capistrano, like:
+
+```ruby
+set :copy_dir,      "/tmp/#{application}"   # path where files are temporarily put before sending them to the servers
+set :copy_exclude,  ".git*"                 # we exclude the .git repo so that nobody is able to temper with the release
+
+#Callback triggers to add your own steps within (in order)
+on 'strategy:before:bundle',      'some:custom:task'
+on 'strategy:after:bundle',       'some:custom:task'
+on 'strategy:before:compression', 'some:custom:task'
+on 'strategy:after:compression',  'some:custom:task'
+on 'strategy:before:distribute',  'some:custom:task'
+on 'strategy:after:distribute',   'some:custom:task'
+```
+
+Copyright © 2011-2012 Rudolf Schmidt. Released under the MIT license.
+

data/capistrano-strategy-copy-bundled.gemspec

@@ -1,12 +1,12 @@
 # -*- encoding: utf-8 -*-
 $:.push File.expand_path("../lib", __FILE__)
-require 'capistrano-strategy-copy-bundled'
+require 'capistrano-strategy-copy-bundled/version'
 
 Gem::Specification.new do |s|
   s.name        = "capistrano-strategy-copy-bundled"
   s.version     = CapistranoStrategyCopyBundled::VERSION
-  s.authors     = ["Rudolf Schmidt"]
-  
+  s.authors     = ["Rudolf Schmidt", "Tom Meier"]
+
   s.homepage    = "http://github.com/rudionrails/capistrano-strategy-copy-bundled"
   s.summary     = %q{Capistrano copy recipe to transfer files already pre-bundled}
   s.description = %q{Bundle all gems in the copy directory and then send it to all servers}
@@ -19,6 +19,7 @@ Gem::Specification.new do |s|
   s.require_paths = ["lib"]
 
   # specify any dependencies here; for example:
-  # s.add_development_dependency "rspec"
+  s.add_development_dependency "rspec"
   s.add_runtime_dependency "capistrano", "~> 2"
+  s.add_runtime_dependency "bundler", ">= 1.2" #Required for package --all
 end

data/lib/capistrano-strategy-copy-bundled.rb

@@ -1,4 +1,4 @@
-module CapistranoStrategyCopyBundled
-  VERSION = '0.6.0'
-  
-end
+module CapistranoStrategyCopyBundled;  end
+
+require 'capistrano-strategy-copy-bundled/version'
+require 'capistrano/recipes/deploy/strategy/copy_bundled'

data/lib/capistrano-strategy-copy-bundled/version.rb

@@ -0,0 +1,3 @@
+module CapistranoStrategyCopyBundled
+  VERSION = '0.7.0'
+end

data/lib/capistrano/recipes/deploy/strategy/copy_bundled.rb

@@ -1,3 +1,5 @@
+require 'bundler/deployment'
+require 'capistrano'
 require 'capistrano/recipes/deploy/strategy/copy'
 
 module Capistrano
@@ -6,121 +8,63 @@ module Capistrano
 
       class CopyBundled < Copy
 
-        # @overload
+        def initialize(config = {})
+          super(config)
+
+          #Initialize with default bundler/capistrano tasks (bundle:install)
+          configuration.set :rake, lambda { "#{configuration.fetch(:bundle_cmd, "bundle")} exec rake" } unless configuration.exists?(:rake)
+          Bundler::Deployment.define_task(configuration, :task, :except => { :no_release => true })
+        end
+
         def deploy!
-          if copy_cache
-            if File.exists?(copy_cache)
-              logger.debug "refreshing local cache to revision #{revision} at #{copy_cache}"
-              system(source.sync(revision, copy_cache))
-            else
-              logger.debug "preparing local cache at #{copy_cache}"
-              system(source.checkout(revision, copy_cache))
-            end
-
-            # Check the return code of last system command and rollback if not 0
-            unless $? == 0
-              raise Capistrano::Error, "shell command failed with return code #{$?}"
-            end
-
-            FileUtils.mkdir_p(destination)
-
-            logger.debug "copying cache to deployment staging area #{destination}"
-            Dir.chdir(copy_cache) do
-              queue = Dir.glob("*", File::FNM_DOTMATCH)
-              while queue.any?
-                item = queue.shift
-                name = File.basename(item)
-
-                next if name == "." || name == ".."
-                next if copy_exclude.any? { |pattern| File.fnmatch(pattern, item) }
-
-                if File.symlink?(item)
-                  FileUtils.ln_s(File.readlink(item), File.join(destination, item))
-                elsif File.directory?(item)
-                  queue += Dir.glob("#{item}/*", File::FNM_DOTMATCH)
-                  FileUtils.mkdir(File.join(destination, item))
-                else
-                  FileUtils.ln(item, File.join(destination, item))
-                end
-              end
-            end
-          else
-            logger.debug "getting (via #{copy_strategy}) revision #{revision} to #{destination}"
-            system(command)
-
-            if copy_exclude.any?
-              logger.debug "processing exclusions..."
-
-              copy_exclude.each do |pattern|
-                delete_list = Dir.glob(File.join(destination, pattern), File::FNM_DOTMATCH)
-                # avoid the /.. trap that deletes the parent directories
-                delete_list.delete_if { |dir| dir =~ /\/\.\.$/ }
-                FileUtils.rm_rf(delete_list.compact)
-              end
-            end
-          end
+          logger.info "running :copy_bundled strategy"
+
+          copy_cache ? run_copy_cache_strategy : run_copy_strategy
 
-          File.open(File.join(destination, "REVISION"), "w") { |f| f.puts(revision) }
+          create_revision_file
 
-          # execute bundler
+          configuration.trigger('strategy:before:bundle')
+          #Bundle all gems
           bundle!
+          configuration.trigger('strategy:after:bundle')
 
-          logger.trace "compressing #{destination} to #{filename}"
-          Dir.chdir(copy_dir) { system(compress(File.basename(destination), File.basename(filename)).join(" ")) }
+          logger.info "compressing repository"
+          configuration.trigger('strategy:before:compression')
+          compress_repository
+          configuration.trigger('strategy:after:compression')
 
+
+          logger.info "distributing packaged repository"
+
+          configuration.trigger('strategy:before:distribute')
           distribute!
+          configuration.trigger('strategy:after:distribute')
         ensure
-          FileUtils.rm filename rescue nil
-          FileUtils.rm_rf destination rescue nil
+          rollback_changes
         end
 
-
         private
 
         def bundle!
-          logger.trace "running bundler in #{destination}..."
-
-          bundle_cmd      = configuration[:bundle_cmd]        || "bundle"
-          bundle_flags    = configuration[:bundle_flags]      || "--deployment --quiet"
-          bundle_dir      = configuration[:bundle_dir]        || File.join('vendor', 'bundle')
-          bundle_gemfile  = configuration[:bundle_gemfile]    || File.join("Gemfile")
-          bundle_without  = [*(configuration[:bundle_without] || [:development, :test])].compact
+          bundle_cmd      = configuration.fetch(:bundle_cmd, "bundle")
+          bundle_gemfile  = configuration.fetch(:bundle_gemfile, "Gemfile")
+          bundle_dir      = configuration.fetch(:bundle_dir, 'vendor/bundle')
+          bundle_flags    = configuration.fetch(:bundle_flags, "--deployment --quiet")
+          bundle_without = [*configuration.fetch(:bundle_without, [:development, :test])].compact
 
-          args = ["--gemfile #{bundle_gemfile}"]
+          args = ["--gemfile #{File.join(destination, bundle_gemfile)}"]
           args << "--path #{bundle_dir}" unless bundle_dir.to_s.empty?
-          args << bundle_flags.to_s
+          args << bundle_flags.to_s unless bundle_flags.to_s.empty?
           args << "--without #{bundle_without.join(" ")}" unless bundle_without.empty?
 
-          cmd = "#{bundle_cmd} install #{args.join(' ')}"
-          Dir.chdir(destination) do
-            defined?(Bundler) ? with_original_env { system(cmd) } : system(cmd)
+          Bundler.with_clean_env do
+            logger.info "installing gems to local cache : #{destination}..."
+            run_locally "cd #{destination} && #{bundle_cmd} install #{args.join(' ').strip}"
 
-            # Check the return code of last system command and rollback if not 0
-            raise Capistrano::Error, "shell command failed with return code #{$?}" unless $? == 0
+            logger.info "packaging gems for bundler in #{destination}..."
+            run_locally "cd #{destination} && #{bundle_cmd} package --all"
           end
         end
-
-        # This method should be built-in to Bundler 1.1+
-        def with_original_env
-          original_env = ENV.to_hash
-
-          begin
-            # clean the ENV from Bundler settings
-            ENV.delete( 'RUBYOPT' )
-            ENV.keys.each { |k| ENV.delete(k) if k =~ /^bundle_/i }  #remove any BUNDLE_* keys
-
-            yield
-          ensure
-            ENV.replace( original_env )
-          end
-        end
-
-        # Distributes the file to the remote servers
-        def distribute!
-          upload( filename, remote_filename, :via => configuration[:copy_via] || :sftp )
-          run "cd #{configuration[:releases_path]} && #{decompress(remote_filename).join(" ")} && rm #{remote_filename}"
-        end
-
       end
 
     end

data/spec/lib/capistrano/recipes/deploy/strategy/copy_bundled_spec.rb

@@ -0,0 +1,116 @@
+require 'spec_helper'
+
+describe Capistrano::Deploy::Strategy::CopyBundled do
+
+  let(:source)      { mock('source') }
+  let(:logger)      { mock('logger', :info => true, :debug => true) }
+  let(:trigger)     { mock('ConfTrigger') }
+  let(:destination) { '/some/where/here/' }
+  let(:config) { mock('Config', :application => "captest",
+                      :releases_path => "/u/apps/test/releases",
+                      :release_path => "/u/apps/test/releases/1234567890",
+                      :real_revision => "154",
+                      :trigger => trigger,
+                      :exists? => false,
+                      :set => true,
+                      :[] => 'hello',
+                      :logger => logger,
+                      :fetch => ''
+                      )}
+  let(:strategy) { Capistrano::Deploy::Strategy::CopyBundled.new(config) }
+
+  before do
+    #Initialisation
+    Bundler::Deployment.should_receive(:define_task).once
+
+    [:copy_cache, :run_copy_strategy, :run_locally, :run].each do |method_call|
+      Capistrano::Deploy::Strategy::CopyBundled.any_instance.stub(method_call) { nil }
+    end
+
+    # #Key base class copy commands
+    [:create_revision_file,  :compress_repository, :distribute!, :rollback_changes].each do |main_call|
+      Capistrano::Deploy::Strategy::CopyBundled.any_instance.should_receive(main_call).once
+    end
+  end
+
+  context 'rake definition' do
+    it 'sets rake command by default' do
+      config.stub(:exists?).with(:rake) { false }
+      config.should_receive(:set).with(:rake, anything).once { true }
+    end
+
+    it 'uses any existing rake command if already exists' do
+      config.stub(:exists?).with(:rake) { true }
+      config.should_not_receive(:set).with(:rake, anything)
+    end
+
+    after do
+      Capistrano::Deploy::Strategy::CopyBundled.new(config).deploy!
+    end
+  end
+
+  context 'with existing copy cache' do
+    let(:copy_cache_dir) { '/u/tmp/copy-cache' }
+    before do
+      strategy.stub!(:copy_cache => copy_cache_dir)
+    end
+
+    it 'utilises existing copy cache strategy' do
+      strategy.should_receive(:run_copy_cache_strategy).once
+      strategy.should_not_receive(:run_copy_strategy)
+      strategy.deploy!
+    end
+  end
+
+  context 'with new copy cache' do
+    before do
+      strategy.stub!(:copy_cache => nil)
+    end
+
+    it 'initialises copy strategy' do
+      strategy.should_receive(:run_copy_strategy).once
+      strategy.should_not_receive(:run_copy_cache_strategy)
+      strategy.deploy!
+    end
+  end
+
+  context 'triggers' do
+    it 'custom calls during actions' do
+      expected_triggers = [ "strategy:before:bundle",
+                            "strategy:after:bundle",
+                            "strategy:before:compression",
+                            "strategy:after:compression",
+                            "strategy:before:distribute",
+                            "strategy:after:distribute"]
+
+      expected_triggers.each do |trigger_name|
+        config.should_receive(:trigger).with(trigger_name).once
+      end
+      strategy.deploy!
+    end
+  end
+
+  context 'bundle!' do
+    let(:custom_bundle_cmd) { 'ANY_VAR=true bundle' }
+
+    before do
+      strategy.stub(:run_copy_cache_strategy => true, :run => true, :destination => destination)
+
+      config.stub(:fetch).with(:bundle_dir, 'vendor/bundle')  { 'vendor/bundle' }
+      config.stub(:fetch).with(:bundle_gemfile, 'Gemfile')    { 'Gemfile' }
+      config.stub(:fetch).with(:bundle_cmd, 'bundle' ) { custom_bundle_cmd }
+      config.stub(:fetch).with(:bundle_without, [:development, :test]) { [:development, :test, :staging] }
+
+      Bundler.should_receive(:with_clean_env).once.and_yield
+    end
+
+    it 'runs bundle install locally and package' do
+      strategy.should_receive(:run_locally).with("cd #{destination} && #{custom_bundle_cmd} install --gemfile #{File.join(destination, 'Gemfile')} --path vendor/bundle --without development test staging").once
+      strategy.should_receive(:run_locally).with("cd #{destination} && ANY_VAR=true bundle package --all").once
+    end
+
+    after do
+      strategy.deploy!
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,13 @@
+require 'capistrano-strategy-copy-bundled'
+
+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

metadata

@@ -1,73 +1,108 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: capistrano-strategy-copy-bundled
-version: !ruby/object:Gem::Version 
+version: !ruby/object:Gem::Version
+  version: 0.7.0
   prerelease: 
-  version: 0.6.0
 platform: ruby
-authors: 
-  - Rudolf Schmidt
+authors:
+- Rudolf Schmidt
+- Tom Meier
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2011-10-19 00:00:00 +02:00
-default_executable: 
-dependencies: 
-  - !ruby/object:Gem::Dependency 
-    name: capistrano
-    prerelease: false
-    requirement: &id001 !ruby/object:Gem::Requirement 
-      none: false
-      requirements: 
-        - - ~>
-          - !ruby/object:Gem::Version 
-            version: "2"
-    type: :runtime
-    version_requirements: *id001
+date: 2013-02-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: capistrano
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '1.2'
 description: Bundle all gems in the copy directory and then send it to all servers
 email: 
 executables: []
-
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
-  - .gitignore
-  - Gemfile
-  - LICENSE.txt
-  - README.rdoc
-  - Rakefile
-  - capistrano-strategy-copy-bundled.gemspec
-  - lib/capistrano-strategy-copy-bundled.rb
-  - lib/capistrano/recipes/deploy/strategy/copy_bundled.rb
-has_rdoc: true
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- capistrano-strategy-copy-bundled.gemspec
+- lib/capistrano-strategy-copy-bundled.rb
+- lib/capistrano-strategy-copy-bundled/version.rb
+- lib/capistrano/recipes/deploy/strategy/copy_bundled.rb
+- spec/lib/capistrano/recipes/deploy/strategy/copy_bundled_spec.rb
+- spec/spec_helper.rb
 homepage: http://github.com/rudionrails/capistrano-strategy-copy-bundled
 licenses: []
-
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
-  - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: "0"
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: capistrano-strategy-copy-bundled
-rubygems_version: 1.5.1
+rubygems_version: 1.8.25
 signing_key: 
 specification_version: 3
 summary: Capistrano copy recipe to transfer files already pre-bundled
-test_files: []
-
+test_files:
+- spec/lib/capistrano/recipes/deploy/strategy/copy_bundled_spec.rb
+- spec/spec_helper.rb
+has_rdoc: 

data/README.rdoc

@@ -1,33 +0,0 @@
-= Capistrano Strategy: Copy Bundled
-This recipe for capistrano utilizes the regular copy strategy. However, instead of bundling the gems on the remote servers,
-they are already pre-bundled on the deploy machine and sent as one package.
-
-In some networks, due to security reasons, production servers are not allowed to access the internal company network. When
-that is the case, you are not able access your internally written gems. Also, these kind of servers usually and intentionally
-know nothing about version control or are even behind a firewall with blocked access to runygems or github and the likes.
-
-This capistrano recipe tries to help out in these scenarios.
-
-== Installation
-# for system wide usage
-gem install 'capistrano-strategy-copy-bundled'
-
-# or just in your Gemfile
-gem 'capistrano-strategy-copy-bundled'
-
-
-== Usage
-As this recipe does it's own bundling, there is not need to: require 'bundler/capistrano'.
-
-All you have to do in your `config/deploy.rb`:
-
-  require 'capistrano-strategy-copy-bundled'
-  set :deploy_via,    :copy_bundled           # bundle gems locally and send them packed to all servers
-
-Additionally to that, you can set the usual options when using the regular :copy strategy for capistrano, like:
-  set :copy_dir,      "/tmp/#{application}"   # path where files are temporarily put before sending them to the servers
-  set :copy_exclude,  ".git*"                 # we exclude the .git repo so that nobody is able to temper with the release
-  
-
-== Copyright
-Copyright (c) 2011 Rudolf Schmidt See LICENSE.txt for details.