minmb-capistrano 2.15.4

data/Gemfile

@@ -0,0 +1,13 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in capistrano.gemspec
+gemspec
+
+#
+# Development Dependencies from the Gemfile
+# are merged here.
+#
+group :development do
+  gem "rake"
+  gem "pry"
+end

data/README.md

@@ -0,0 +1,94 @@
+## Capistrano
+
+[![Build
+Status](https://secure.travis-ci.org/capistrano/capistrano.png)](http://travis-ci.org/capistrano/capistrano)[![Code Climate](https://codeclimate.com/badge.png)](https://codeclimate.com/github/capistrano/capistrano)
+
+
+Capistrano is a utility and framework for executing commands in parallel on
+multiple remote machines, via SSH. It uses a simple DSL (borrowed in part from
+[Rake](http://rake.rubyforge.org/)) that allows you to define _tasks_, which may
+be applied to machines in certain roles. It also supports tunneling connections
+via some gateway machine to allow operations to be performed behind VPN's and
+firewalls.
+
+Capistrano was originally designed to simplify and automate deployment of web
+applications to distributed environments, and originally came bundled with a set
+of tasks designed for deploying Rails applications.
+
+## Documentation
+
+* [https://github.com/capistrano/capistrano/wiki](https://github.com/capistrano/capistrano/wiki)
+
+## DEPENDENCIES
+
+* [Net::SSH](http://net-ssh.rubyforge.org)
+* [Net::SFTP](http://net-ssh.rubyforge.org)
+* [Net::SCP](http://net-ssh.rubyforge.org)
+* [Net::SSH::Gateway](http://net-ssh.rubyforge.org)
+* [HighLine](http://highline.rubyforge.org)
+* [Ruby](http://www.ruby-lang.org/en/) ≥ 1.8.7
+
+If you want to run the tests, you'll also need to install the dependencies with
+Bundler, see the `Gemfile` within .
+
+## ASSUMPTIONS
+
+Capistrano is "opinionated software", which means it has very firm ideas about
+how things ought to be done, and tries to force those ideas on you. Some of the
+assumptions behind these opinions are:
+
+* You are using SSH to access the remote servers.
+* You either have the same password to all target machines, or you have public
+  keys in place to allow passwordless access to them.
+
+Do not expect these assumptions to change.
+
+## USAGE
+
+In general, you'll use Capistrano as follows:
+
+* Create a recipe file ("capfile" or "Capfile").
+* Use the `cap` script to execute your recipe.
+
+Use the `cap` script as follows:
+
+    cap sometask
+
+By default, the script will look for a file called one of `capfile` or
+`Capfile`. The `sometask` text indicates which task to execute. You can do
+"cap -h" to see all the available options and "cap -T" to see all the available
+tasks.
+
+## CONTRIBUTING:
+
+* Fork Capistrano
+* Create a topic branch - `git checkout -b my_branch`
+* Rebase your branch so that all your changes are reflected in one
+  commit
+* Push to your branch - `git push origin my_branch`
+* Create a Pull Request from your branch, include as much documentation
+  as you can in the commit message/pull request, following these
+[guidelines on writing a good commit message](http://tbaggery.com/2008/04/19/a-note-about-git-commit-messages.html)
+* That's it!
+
+
+## LICENSE:
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,11 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/*_test.rb'
+  test.verbose = true
+end
+
+task :default => :test

data/bin/cap

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+
+require 'capistrano/cli'
+Capistrano::CLI.execute

data/bin/capify

@@ -0,0 +1,92 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+require 'fileutils'
+
+OptionParser.new do |opts|
+  opts.banner = "Usage: #{File.basename($0)} [path]"
+
+  opts.on("-h", "--help", "Displays this help info") do
+    puts opts
+    exit 0
+  end
+
+  begin
+    opts.parse!(ARGV)
+  rescue OptionParser::ParseError => e
+    warn e.message
+    puts opts
+    exit 1
+  end
+end
+
+if ARGV.empty?
+  abort "Please specify the directory to capify, e.g. `#{File.basename($0)} .'"
+elsif !File.exists?(ARGV.first)
+  abort "`#{ARGV.first}' does not exist."
+elsif !File.directory?(ARGV.first)
+  abort "`#{ARGV.first}' is not a directory."
+elsif ARGV.length > 1
+  abort "Too many arguments; please specify only the directory to capify."
+end
+
+def unindent(string)
+  indentation = string[/\A\s*/]
+  string.strip.gsub(/^#{indentation}/, "")
+end
+
+files = {
+  "Capfile" => unindent(<<-FILE),
+
+    load 'deploy'
+
+    # Uncomment if you are using Rails' asset pipeline
+    # load 'deploy/assets'
+
+    load 'config/deploy' # remove this line to skip loading any of the default tasks
+  FILE
+
+  "config/deploy.rb" => 'set :application, "set your application name here"
+set :repository,  "set your repository location here"
+
+# set :scm, :git # You can set :scm explicitly or Capistrano will make an intelligent guess based on known version control directory names
+# Or: `accurev`, `bzr`, `cvs`, `darcs`, `git`, `mercurial`, `perforce`, `subversion` or `none`
+
+role :web, "your web-server here"                          # Your HTTP server, Apache/etc
+role :app, "your app-server here"                          # This may be the same as your `Web` server
+role :db,  "your primary db-server here", :primary => true # This is where Rails migrations will run
+role :db,  "your slave db-server here"
+
+# if you want to clean up old releases on each deploy uncomment this:
+# after "deploy:restart", "deploy:cleanup"
+
+# if you\'re still using the script/reaper helper you will need
+# these http://github.com/rails/irs_process_scripts
+
+# If you are using Passenger mod_rails uncomment this:
+# namespace :deploy do
+#   task :start do ; end
+#   task :stop do ; end
+#   task :restart, :roles => :app, :except => { :no_release => true } do
+#     run "#{try_sudo} touch #{File.join(current_path,\'tmp\',\'restart.txt\')}"
+#   end
+# end'}
+
+base = ARGV.shift
+files.each do |file, content|
+  file = File.join(base, file)
+  if File.exists?(file)
+    warn "[skip] '#{file}' already exists"
+  elsif File.exists?(file.downcase)
+    warn "[skip] '#{file.downcase}' exists, which could conflict with `#{file}'"
+  else
+    unless File.exists?(File.dirname(file))
+      puts "[add] making directory '#{File.dirname(file)}'"
+      FileUtils.mkdir(File.dirname(file))
+    end
+    puts "[add] writing '#{file}'"
+    File.open(file, "w") { |f| f.write(content) }
+  end
+end
+
+puts "[done] capified!"

data/capistrano.gemspec

@@ -0,0 +1,40 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "capistrano/version"
+
+Gem::Specification.new do |s|
+
+  s.name        = "minmb-capistrano"
+  s.version     = Capistrano::Version.to_s
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Jamis Buck", "Lee Hambley"]
+  s.email       = ["jamis@jamisbuck.org", "lee.hambley@gmail.com"]
+  s.homepage    = "http://github.com/minmb/capistrano"
+  s.summary     = %q{Capistrano - Welcome to easy deployment with Ruby over SSH}
+  s.description = %q{Capistrano is a utility and framework for executing commands in parallel on multiple remote machines, via SSH.}
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+  s.extra_rdoc_files = [
+    "README.md"
+  ]
+
+  s.specification_version = 3 if s.respond_to? :specification_version
+
+  if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+    s.add_runtime_dependency(%q<highline>, [">= 0"])
+    s.add_runtime_dependency(%q<minmb-net-ssh>, [">= 2.0.14"])
+    s.add_runtime_dependency(%q<net-sftp>, [">= 2.0.0"])
+    s.add_runtime_dependency(%q<net-scp>, [">= 1.0.0"])
+    s.add_runtime_dependency(%q<net-ssh-gateway>, [">= 1.1.0"])
+    s.add_development_dependency(%q<mocha>, ["0.9.12"])
+  else
+    s.add_dependency(%q<minmb-net-ssh>, [">= 2.0.14"])
+    s.add_dependency(%q<net-sftp>, [">= 2.0.0"])
+    s.add_dependency(%q<net-scp>, [">= 1.0.0"])
+    s.add_dependency(%q<net-ssh-gateway>, [">= 1.1.0"])
+    s.add_dependency(%q<highline>, [">= 0"])
+    s.add_dependency(%q<mocha>, ["0.9.12"])
+  end
+end

data/lib/capistrano.rb

@@ -0,0 +1,5 @@
+require 'capistrano/fix_rake_deprecated_dsl'
+
+require 'capistrano/configuration'
+require 'capistrano/extensions'
+require 'capistrano/ext/string'

data/lib/capistrano/callback.rb

@@ -0,0 +1,45 @@
+module Capistrano
+  class Callback
+    attr_reader :source, :options, :only, :except
+
+    def initialize(source, options={})
+      @source = source
+      @options = options
+      @only = Array(options[:only]).map { |v| v.to_s }
+      @except = Array(options[:except]).map { |v| v.to_s }
+    end
+
+    def applies_to?(task)
+      if task && only.any?
+        return only.include?(task.fully_qualified_name)
+      elsif task && except.any?
+        return !except.include?(task.fully_qualified_name)
+      else
+        return true
+      end
+    end
+  end
+
+  class ProcCallback < Callback
+    def call
+      source.call
+    end
+  end
+
+  class TaskCallback < Callback
+    attr_reader :config
+
+    def initialize(config, source, options={})
+      super(source, options)
+      @config = config
+    end
+
+    def call
+      config.find_and_execute_task(source)
+    end
+
+    def applies_to?(task)
+      super && (task.nil? || task.fully_qualified_name != source.to_s)
+    end
+  end
+end

data/lib/capistrano/cli.rb

@@ -0,0 +1,47 @@
+require 'capistrano'
+require 'capistrano/cli/execute'
+require 'capistrano/cli/help'
+require 'capistrano/cli/options'
+require 'capistrano/cli/ui'
+
+module Capistrano
+  # The CLI class encapsulates the behavior of capistrano when it is invoked
+  # as a command-line utility. This allows other programs to embed Capistrano
+  # and preserve its command-line semantics.
+  class CLI
+    # The array of (unparsed) command-line options
+    attr_reader :args
+
+    # Create a new CLI instance using the given array of command-line parameters
+    # to initialize it. By default, +ARGV+ is used, but you can specify a
+    # different set of parameters (such as when embedded cap in a program):
+    #
+    #   require 'capistrano/cli'
+    #   Capistrano::CLI.parse(%W(-vvvv -f config/deploy update_code)).execute!
+    #
+    # Note that you can also embed cap directly by creating a new Configuration
+    # instance and setting it up, The above snippet, redone using the
+    # Configuration class directly, would look like:
+    #
+    #   require 'capistrano'
+    #   require 'capistrano/cli'
+    #   config = Capistrano::Configuration.new
+    #   config.logger.level = Capistrano::Logger::TRACE
+    #   config.set(:password) { Capistrano::CLI.password_prompt }
+    #   config.load "config/deploy"
+    #   config.update_code
+    #
+    # There may be times that you want/need the additional control offered by
+    # manipulating the Configuration directly, but generally interfacing with
+    # the CLI class is recommended.
+    def initialize(args)
+      @args = args.dup
+      $stdout.sync = true # so that Net::SSH prompts show up
+    end
+
+    # Mix-in the actual behavior
+    include Execute, Options, UI
+    include Help # needs to be included last, because it overrides some methods
+
+  end
+end

data/lib/capistrano/cli/execute.rb

@@ -0,0 +1,85 @@
+require 'capistrano/configuration'
+
+module Capistrano
+  class CLI
+    module Execute
+      def self.included(base) #:nodoc:
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        # Invoke capistrano using the ARGV array as the option parameters. This
+        # is what the command-line capistrano utility does.
+        def execute
+          parse(ARGV).execute!
+        end
+      end
+
+      # Using the options build when the command-line was parsed, instantiate
+      # a new Capistrano configuration, initialize it, and execute the
+      # requested actions.
+      #
+      # Returns the Configuration instance used, if successful.
+      def execute!
+        config = instantiate_configuration(options)
+        config.debug = options[:debug]
+        config.dry_run = options[:dry_run]
+        config.preserve_roles = options[:preserve_roles]
+        config.logger.level = options[:verbose]
+
+        set_pre_vars(config)
+        load_recipes(config)
+
+        config.trigger(:load)
+        execute_requested_actions(config)
+        config.trigger(:exit)
+
+        config
+      rescue Exception => error
+        handle_error(error)
+      end
+
+      def execute_requested_actions(config)
+        Array(options[:vars]).each { |name, value| config.set(name, value) }
+
+        Array(options[:actions]).each do |action|
+          config.find_and_execute_task(action, :before => :start, :after => :finish)
+        end
+      end
+
+      def set_pre_vars(config) #:nodoc:
+        config.set :password, options[:password]
+        Array(options[:pre_vars]).each { |name, value| config.set(name, value) }
+      end
+
+      def load_recipes(config) #:nodoc:
+        # load the standard recipe definition
+        config.load "standard"
+
+        # load systemwide config/recipe definition
+        config.load(options[:sysconf]) if options[:sysconf] && File.file?(options[:sysconf])
+
+        # load user config/recipe definition
+        config.load(options[:dotfile]) if options[:dotfile] && File.file?(options[:dotfile])
+
+        Array(options[:recipes]).each { |recipe| config.load(recipe) }
+      end
+
+      # Primarily useful for testing, but subclasses of CLI could conceivably
+      # override this method to return a Configuration subclass or replacement.
+      def instantiate_configuration(options={}) #:nodoc:
+        Capistrano::Configuration.new(options)
+      end
+
+      def handle_error(error) #:nodoc:
+        case error
+        when Net::SSH::AuthenticationFailed
+          abort "authentication failed for `#{error.message}'"
+        when Capistrano::Error
+          abort(error.message)
+        else raise error
+        end
+      end
+    end
+  end
+end