le1t0-capistrano 2.5.18.001

data/README

@@ -0,0 +1,102 @@
+= 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. The deployment tasks are now (as of Capistrano 2.0) opt-in and require clients to explicitly put
+"load 'deploy'" in their recipes.
+
+== Documentation
+
+We know that documentation is something that really lets us down, that's why there is a repository for a handbook below, please open an issue on it if you would like something documented:
+
+* http://github.com/leehambley/capistrano-handbook
+
+If you prefer the wiki style of documentation, then please see our wiki
+
+* http://wiki.capify.org
+
+Due to a failure of MySQL with PHP, searches shorter than three characters are all but ignored, we're going to rectify this, but in the meantime, please do what you can, tickets opened on the handbook for the wiki will be answered too, so please let us know if you don't find something you needed.
+
+We take bug reports via lighthouse app, you can find that page here:
+
+* http://capistrano.lighthouseapp.com
+
+More documentation is on the way, if in doubt try opening the recipes that ship with capistrano.
+
+== DEPENDENCIES
+
+* Net::SSH v2 (http://net-ssh.rubyforge.org)
+* Net::SFTP v2 (http://net-ssh.rubyforge.org)
+* Net::SCP v1 (http://net-ssh.rubyforge.org)
+* Net::SSH::Gateway v1 (http://net-ssh.rubyforge.org)
+* HighLine (http://highline.rubyforge.org)
+
+If you want to run the tests, you'll also need to have the following dependencies installed:
+
+* Echoe (for the Rakefile)
+* Mocha (http://mocha.rubyforge.org)
+
+== 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 +someaction+ 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.
+
+== Capistrano Edge
+
+If you want to try Capistrano code that hasn't been formerly released yet, this repository now includes a gemspec that should build what you need, here's how to get a copy:
+
+    git clone git://github.com/capistrano/capistrano.git capistrano-capistrano
+    cd capistrano-capsitrano
+    rake package
+    sudo gem install pkg/capistrano-*.gem
+
+This will install the most recent version of capistrano and make it available for both cap, and capify.
+
+We recommend that you capify a new test application, as the resulting files are different to previous versions.
+
+If you have multiple versions of capistrano (or indeed any gem with a binary) installed, you can call `cap` like so to specify which version to use:
+
+    cap _2.5.5_ deploy
+    cap _2.5.6_ deploy:setup
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2005-2008 Jamis Buck <jamis@37signals.com>
+
+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,36 @@
+require "./lib/capistrano/version"
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.version
+    gem.name            = "le1t0-capistrano"
+    gem.executables     = %W(capify cap)
+    gem.summary         = %Q{Capistrano – Welcome to easy deployment with Ruby over SSH}
+    gem.description     = %Q{Capistrano is a utility and framework for executing commands in parallel on multiple remote machines, via SSH.}
+    gem.homepage        = "http://github.com/le1t0/capistrano"
+    gem.email           = [ "dev@ewout.to" ]
+    gem.authors         = [ "Le1t0" ]
+    gem.add_dependency  "net-ssh",          ">=2.0.14"
+    gem.add_dependency  "net-sftp",         ">=2.0.0"
+    gem.add_dependency  "net-scp",          ">=1.0.0"
+    gem.add_dependency  "net-ssh-gateway",  ">=1.0.0"
+    gem.add_dependency  "highline"
+    gem.add_development_dependency "mocha", ">= 0"
+  end
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+Jeweler::GemcutterTasks.new
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/*_test.rb'
+  test.verbose = true
+end
+
+task :test => :check_dependencies
+task :default => :test
+

data/VERSION

@@ -0,0 +1 @@
+2.5.18.001

data/bin/cap

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

data/bin/capify

@@ -0,0 +1,86 @@
+#!/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' if respond_to?(:namespace) # cap2 differentiator
+    Dir['vendor/plugins/*/recipes/*.rb'].each { |plugin| load(plugin) }
+
+    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, :subversion
+# 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 are using Passenger mod_rails uncomment this:
+# if you\'re still using the script/reapear helper you will need
+# these http://github.com/rails/irs_process_scripts
+
+# 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/lib/capistrano.rb

@@ -0,0 +1,2 @@
+require 'capistrano/configuration'
+require 'capistrano/extensions'

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

data/lib/capistrano/cli/help.rb

@@ -0,0 +1,125 @@
+module Capistrano
+  class CLI
+    module Help
+      LINE_PADDING = 7
+      MIN_MAX_LEN  = 30
+      HEADER_LEN   = 60
+
+      def self.included(base) #:nodoc:
+        base.send :alias_method, :execute_requested_actions_without_help, :execute_requested_actions
+        base.send :alias_method, :execute_requested_actions, :execute_requested_actions_with_help
+      end
+
+      def execute_requested_actions_with_help(config)
+        if options[:tasks]
+          task_list(config, options[:tasks])
+        elsif options[:explain]
+          explain_task(config, options[:explain])
+        else
+          execute_requested_actions_without_help(config)
+        end
+      end
+
+      def task_list(config, pattern = true) #:nodoc:
+        tool_output = options[:tool]
+
+        if pattern.is_a?(String)
+          tasks = config.task_list(:all).select {|t| t.fully_qualified_name =~ /#{pattern}/}
+        end
+        if tasks.nil? || tasks.length == 0
+          warn "Pattern '#{pattern}' not found. Listing all tasks.\n\n" if !tool_output && !pattern.is_a?(TrueClass)
+          tasks = config.task_list(:all)
+        end
+
+        if tasks.empty?
+          warn "There are no tasks available. Please specify a recipe file to load." unless tool_output
+        else
+          all_tasks_length = tasks.length
+          if options[:verbose].to_i < 1
+            tasks = tasks.reject { |t| t.description.empty? || t.description =~ /^\[internal\]/ }
+          end
+
+          tasks = tasks.sort_by { |task| task.fully_qualified_name }
+
+          longest = tasks.map { |task| task.fully_qualified_name.length }.max
+          max_length = output_columns - longest - LINE_PADDING
+          max_length = MIN_MAX_LEN if max_length < MIN_MAX_LEN
+
+          tasks.each do |task|
+            if tool_output
+              puts "cap #{task.fully_qualified_name}"
+            else
+              puts "cap %-#{longest}s # %s" % [task.fully_qualified_name, task.brief_description(max_length)]
+            end
+          end
+
+          unless tool_output
+            if all_tasks_length > tasks.length
+              puts
+              puts "Some tasks were not listed, either because they have no description,"
+              puts "or because they are only used internally by other tasks. To see all"
+              puts "tasks, type `#{File.basename($0)} -vT'."
+            end
+
+            puts
+            puts "Extended help may be available for these tasks."
+            puts "Type `#{File.basename($0)} -e taskname' to view it."
+          end
+        end
+      end
+
+      def explain_task(config, name) #:nodoc:
+        task = config.find_task(name)
+        if task.nil?
+          warn "The task `#{name}' does not exist."
+        else
+          puts "-" * HEADER_LEN
+          puts "cap #{name}"
+          puts "-" * HEADER_LEN
+
+          if task.description.empty?
+            puts "There is no description for this task."
+          else
+            puts format_text(task.description)
+          end
+
+          puts
+        end
+      end
+
+      def long_help #:nodoc:
+        help_text = File.read(File.join(File.dirname(__FILE__), "help.txt"))
+        self.class.ui.page_at = self.class.ui.output_rows - 2
+        self.class.ui.say format_text(help_text)
+      end
+
+      def format_text(text) #:nodoc:
+        formatted = ""
+        text.each_line do |line|
+          indentation = line[/^\s+/] || ""
+          indentation_size = indentation.split(//).inject(0) { |c,s| c + (s[0] == ?\t ? 8 : 1) }
+          line_length = output_columns - indentation_size
+          line_length = MIN_MAX_LEN if line_length < MIN_MAX_LEN
+          lines = line.strip.gsub(/(.{1,#{line_length}})(?:\s+|\Z)/, "\\1\n").split(/\n/)
+          if lines.empty?
+            formatted << "\n"
+          else
+            formatted << lines.map { |l| "#{indentation}#{l}\n" }.join
+          end
+        end
+        formatted
+      end
+
+      def output_columns #:nodoc:
+        if ( @output_columns.nil? ) 
+          if ( self.class.ui.output_cols.nil? || self.class.ui.output_cols > 80 )
+            @output_columns = 80 
+          else
+            @output_columns = self.class.ui.output_cols
+          end
+        end
+        @output_columns 
+      end
+    end
+  end
+end