capistrano-campout 0.0.1

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+.rvmrc

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in capistrano-campout.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,33 @@
+Copyright (c) 2012 Jason Adam Young
+
+MIT 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.
+
+Additional Copyrights
+=====================
+
+This code also contains code from the following people:
+ 
+ rails_config : Copyright (c) 2010 Jacques Crocker
+ deep_merge : Copyright (c) 2008 Steve Midgley, now mainted by Daniel DeLeo
+ eycap : Copyright (c) 2008-2011 Engine Yard
+ capfire : Copyright (c) 2010 Piet Jaspers 10to1
+ capistrano-mountaintop : Copyright (c) 2010 Joshua Nichols.

data/README.md

@@ -0,0 +1,98 @@
+# Capistrano::Campout
+
+Capistrano::Campout is a gem extension to capistrano to post/speak messages 
+and paste logs from a capistrano deployment to a campfire room. Settings are 
+configurable in a "config/campout.yml" and/or "config/campout.local.yml" 
+file. ERB templates are supported for messages and can use all of the 
+capistrano settings.
+ 
+Capistrano::Campout will a speak messages at pre-deployment and 
+post-deployment success or failure. Event sounds are also supported.
+
+## Design goals
+
+Capistrano::Campout is insipred by and borrows concepts (and in some cases code) 
+from two projects: [capistrano-mountaintop](https://github.com/technicalpickles/capistrano-mountaintop) and [capfire](https://github.com/pjaspers/capfire). 
+
+I created my own instead of forking either for the following reasons
+
+* I wanted to use Tinder (Capfire uses broach)
+* I wanted the necessary functionality built in instead of using additional gems (mountaintop depends on capistrano-campfire and capistrano-log_with_awesome)
+* I wanted configuration-file based settings that I can separate into shared (checked into git) and local (git ignored) files
+* I wanted room to expand for my team's needs for utilities for git and github inspection
+* Because I could.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'capistrano-campout'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install capistrano-campout
+
+## Usage
+
+Add a:
+
+	require "capistrano-campout"  
+
+to your capistrano deploy.rb and create a config/campout.yml and/or a config/campout.local.yml with your campfire settings (required)
+
+	campfire:
+	    domain: 'your_campfire_domain'
+	    room: room_id_to_post_to
+	    token: your_campfire_api_token
+
+"config/campout.yml" is meant to be a pre-project file and can contain global settings for everyone. Don't put the api token in a campout.yml file that's part of a public git repository
+
+"config/campout.local.yml" is meant as a local/private configuration file - I'd recommend adding the file to the .gitignore
+
+## Additional Settings
+
+I'll write those up one day. Until that day, use the source, Luke.
+
+## Known Limitations
+
+### Deploy:Cleanup task
+
+Capistrano::Campout requires [Tinder](https://github.com/collectiveidea/tinder) - which requires [ActiveSupport](https://github.com/rails/rails/tree/master/activesupport)
+
+Apparently, Capistrano's "deploy:cleanup" task breaks due to conflicts between Capistrano and ActiveSupport
+
+See:
+
+* [Issue #169](https://github.com/capistrano/capistrano/issues/169)
+* [Issue #170](https://github.com/capistrano/capistrano/issues/170)
+* [Pull Request #175](https://github.com/capistrano/capistrano/pull/175)
+
+Until that's fixed, you'll have to comment out any "deploy:cleanup" invocations 
+
+### Error checking
+
+There isn't much. And there's no tests. The latter might be a feature.
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+## Sources
+
+Capistrano::Campout includes code and ideas from the following projects:
+
+* [rails_config](https://github.com/railsjedi/rails_config) Copyright © 2010 Jacques Crocker
+* [deep_merge](https://github.com/danielsdeleo/deep_merge) Copyright © 2008 Steve Midgley, now mainted by Daniel DeLeo
+* [eycap](https://github.com/engineyard/eycap) Copyright © 2008-2011 Engine Yard
+* [capfire](https://github.com/pjaspers/capfire) Copyright © 2010 Piet Jaspers 10to1
+* [capistrano-mountaintop](https://github.com/technicalpickles/capistrano-mountaintop) Copyright © 2010 Joshua Nichols.
+
+

data/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/capistrano-campout.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/capistrano-campout/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Jason Adam Young"]
+  gem.email         = ["jay@outfielding.net"]
+  gem.description = <<-EOF 
+    Capistrano::Campout is a gem extension to capistrano to post/speak messages and paste logs from a capistrano deployment 
+    to a campfire room. Settings are configurable using ERB in a "config/campout.yml" or "config/campout.local.yml" file. 
+    Capistrano::Campout will a speak a pre-deployment message, and a post-deployment success or failure message. Event sounds
+    are also supported.
+  EOF
+  gem.summary       = %q{Post messages and paste logs from a capistrano deployment to a campfire room}
+  gem.homepage      = %q{https://github.com/jasonadamyoung/capistrano-campout}
+  gem.license       = 'MIT'
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "capistrano-campout"
+  gem.require_paths = ["lib"]
+  gem.version       = Capistrano::Campout::VERSION
+  gem.add_dependency('capistrano', '>= 2.11')
+  gem.add_dependency('tinder', '>= 1.8')
+  gem.add_dependency('grit', '>= 2.4')
+end

data/lib/capistrano-campout/cap_tasks.rb

@@ -0,0 +1,50 @@
+# === COPYRIGHT:
+# Copyright (c) 2012 Jason Adam Young
+# === LICENSE:
+# see LICENSE file
+
+Capistrano::Configuration.instance(:must_exist).load do
+  # Don't bother users who have capfire installed but don't have a ~/.campfire file
+
+  if Capfire.config_file_exists?
+    if Capfire.valid_config?
+      before "deploy:update_code", "capfire:check_for_push"
+      after "deploy:update_code", "capfire:post_to_campfire"
+    else
+      logger.info "Not all required keys found in your .campfire file. Please regenerate."
+    end
+  else
+    logger.info "Couldn't find a .campfire in your home directory."
+  end
+
+
+
+    desc <<-DESC
+This will post to the campfire room as specified in your ~/.campfire. \
+The message posted will contain a link to Github's excellent compare view, \
+the commiters name, the project name and the arguments supplied to cap.
+  DESC
+    task :post_to_campfire do
+      begin
+        source_repo_url = repository
+        deployed_version = previous_revision[0,7] rescue "000000"
+        local_version = `git rev-parse HEAD`[0,7]
+
+        compare_url = Capfire.github_compare_url source_repo_url, deployed_version, local_version
+        message = Capfire.deploy_message(ARGV.join(' '), compare_url, application)
+        message = `cowsay "#{message}"` if Capfire.cowsay?
+
+        if dry_run
+          logger.info "Capfire would have posted:\n#{message}"
+        else
+          Capfire.speak message
+        end
+        logger.info "Posting to Campfire"
+      rescue => e
+        # Making sure we don't make capistrano fail.
+        # Cause nothing sucks donkeyballs like not being able to deploy
+        logger.important e.message
+      end
+    end
+  end
+end

data/lib/capistrano-campout/core.rb

@@ -0,0 +1,202 @@
+# === COPYRIGHT:
+# Copyright (c) 2012 Jason Adam Young
+# === LICENSE:
+# see LICENSE file
+module Capistrano
+  module Campout
+    class Core
+      attr_accessor :settings, :campfire, :room
+    
+      def initialize
+        @settings = Options.new
+        @settings.load!
+      end
+    
+      def local_deployer
+        ENV['USER']
+      end    
+      
+      def git_deployer
+        if(gitutils)
+          gitutils.user_name
+        else
+          nil
+        end
+      end
+      
+      def gitutils
+        @gitutils ||= GitUtils.new('.')
+      end
+      
+      def campout_deployer
+        if(!(deployer = git_deployer))
+          deployer = local_deployer
+        end
+        deployer
+      end
+      
+      def speak(msg)
+        room.speak(msg)
+      end
+      
+      def play(sound)
+        room.play(sound)
+      end
+      
+      def paste(text)
+        room.paste(text)
+      end
+      
+      def campfire
+        @campfire ||= connect_to_campfire
+      end
+      
+      def connect_to_campfire
+        options = {token: settings.campfire.token}
+        if(!settings.campfire.ssl.nil?)
+          options[:ssl] = settings.campfire.ssl
+        end
+        
+        if(!settings.campfire.ssl_verify.nil?)
+          options[:ssl_verify] = settings.campfire.ssl_verify
+        end
+        Tinder::Campfire.new(settings.campfire.domain,options)
+      end
+      
+      def pre_announce(options = {})
+        self.speak(ERB.new(settings.pre_deploy.message).result(options[:binding]))
+        if(!settings.suppress_sounds and settings.pre_deploy.play)
+          self.play(settings.pre_deploy.play)
+        end
+        @pre_announce_time = Time.now
+      end
+      
+      def post_announce_success(options = {})
+        message = ERB.new(settings.post_deploy_success.message).result(options[:binding])
+        if(!settings.suppress_deploy_time and @pre_announce_time)
+          message += " (#{time_period_to_s(Time.now - @pre_announce_time)})"
+        end
+        
+        if(!settings.suppress_github_compare and gitutils)
+          github_compare = true
+          repository = options[:repository] || github_compare = false
+          gitutils.repository = repository
+          previous = options[:previous_revision] || github_compare = false
+          latest = options[:latest_revision] || github_compare = false
+        else
+          github_compare = false
+        end
+      
+        if(gitutils)
+          gitutils.user_name
+        else
+          nil
+        end
+      
+        if(github_compare and gitutils.repository_is_github?)
+          message += " #{gitutils.github_compare_url(previous,latest)}"
+        end
+        
+        self.speak(message)
+        if(!settings.suppress_sounds and settings.post_deploy_success.play)
+          self.play(settings.post_deploy_success.play)
+        end
+        
+        if(!settings.suppress_deploy_log_paste)
+          logger = Capistrano::CampoutLogger
+          log_output = File.open(logger.log_file_path).read
+          self.paste(log_output)
+        end
+        
+        @pre_announce_time = nil
+      end
+      
+      def post_announce_failure(options = {})
+        message = ERB.new(settings.post_deploy_failure.message).result(options[:binding])        
+        self.speak(message)
+        if(!settings.suppress_sounds and settings.post_deploy_failure.play)
+          self.play(settings.post_deploy_failure.play)
+        end
+        
+        if(!settings.suppress_deploy_log_paste)
+          logger = Capistrano::CampoutLogger
+          log_output = File.open(logger.log_file_path).read
+          self.paste(log_output)
+        end
+        @pre_announce_time = nil
+      end
+      
+  
+      def room
+        @room ||= campfire.find_room_by_id(settings.campfire.room)
+      end
+            
+      def will_do(options = {})
+        puts "Before Deployment:"
+        puts "Message: #{ERB.new(settings.pre_deploy.message).result(options[:binding])}"
+        if(!settings.suppress_sounds and settings.pre_deploy.play)
+          puts "Will play sound: #{settings.pre_deploy.play}"
+        else
+          puts "Will not play sound"
+        end
+  
+        puts "\n"
+        puts "After Successful Deployment:"
+        puts "Message: #{ERB.new(settings.post_deploy_success.message).result(options[:binding])}"
+        if(!settings.suppress_sounds and settings.post_deploy_success.play)
+          puts "Will play sound: #{settings.post_deploy_success.play}"
+        else
+          puts "Will not play sound"
+        end
+        if(!settings.suppress_deploy_log_paste)
+          puts "Will paste deployment log"
+        else
+          puts "Will not paste deployment log"
+        end
+        
+        
+        puts "\n"
+        puts "After Failed Deployment:"
+        puts "Message: #{ERB.new(settings.post_deploy_failure.message).result(options[:binding])}"
+        if(!settings.suppress_sounds and settings.post_deploy_failure.play)
+          puts "Will play sound: #{settings.post_deploy_failure.play}"
+        else
+          puts "Will not play sound"
+        end
+        if(!settings.suppress_deploy_log_paste)
+          puts "Will paste deployment log"
+        else
+          puts "Will not paste deployment log"
+        end
+      end
+      
+      # Takes a period of time in seconds and returns it in human-readable form (down to minutes)
+      # code from http://www.postal-code.com/binarycode/2007/04/04/english-friendly-timespan/
+      def time_period_to_s(time_period,abbreviated=false,defaultstring = '')
+       out_str = ''
+       if(time_period.blank?)
+         return defaultstring
+       end
+       interval_array = [ [:weeks, 604800], [:days, 86400], [:hours, 3600], [:minutes, 60], [:seconds, 1] ]
+       interval_array.each do |sub|
+        if time_period >= sub[1] then
+          time_val, time_period = time_period.divmod( sub[1] )
+          if(abbreviated)
+            name = sub[0].to_s.first
+            ( sub[0] != :seconds ? out_str += ", " : out_str += " " ) if out_str != ''
+          else
+            time_val == 1 ? name = sub[0].to_s.chop : name = sub[0].to_s
+            ( sub[0] != :seconds ? out_str += ", " : out_str += " and " ) if out_str != ''
+          end
+          out_str += time_val.to_s + " #{name}"
+        end
+       end
+       if(out_str.blank?)
+         return defaultstring
+       else
+         return out_str
+       end
+      end
+    end
+  end
+end

data/lib/capistrano-campout/deep_merge.rb

@@ -0,0 +1,216 @@
+# deep_merge was written by Steve Midgley, and is now maintained by Daniel DeLeo.
+# The official home of deep_merge on the internet is now
+# https://github.com/danielsdeleo/deep_merge
+# 
+# Copyright (c) 2008 Steve Midgley, released under the MIT license
+
+module DeepMerge
+
+  class InvalidParameter < StandardError; end
+
+  DEFAULT_FIELD_KNOCKOUT_PREFIX = '--'
+
+  # Deep Merge core documentation.
+  # deep_merge! method permits merging of arbitrary child elements. The two top level
+  # elements must be hashes. These hashes can contain unlimited (to stack limit) levels
+  # of child elements. These child elements to not have to be of the same types.
+  # Where child elements are of the same type, deep_merge will attempt to merge them together.
+  # Where child elements are not of the same type, deep_merge will skip or optionally overwrite
+  # the destination element with the contents of the source element at that level.
+  # So if you have two hashes like this:
+  #   source = {:x => [1,2,3], :y => 2}
+  #   dest =   {:x => [4,5,'6'], :y => [7,8,9]}
+  #   dest.deep_merge!(source)
+  #   Results: {:x => [1,2,3,4,5,'6'], :y => 2}
+  # By default, "deep_merge!" will overwrite any unmergeables and merge everything else.
+  # To avoid this, use "deep_merge" (no bang/exclamation mark)
+  #
+  # Options:
+  #   Options are specified in the last parameter passed, which should be in hash format:
+  #   hash.deep_merge!({:x => [1,2]}, {:knockout_prefix => '--'})
+  #   :preserve_unmergeables  DEFAULT: false
+  #      Set to true to skip any unmergeable elements from source
+  #   :knockout_prefix        DEFAULT: nil
+  #      Set to string value to signify prefix which deletes elements from existing element
+  #   :sort_merged_arrays     DEFAULT: false
+  #      Set to true to sort all arrays that are merged together
+  #   :unpack_arrays          DEFAULT: nil
+  #      Set to string value to run "Array::join" then "String::split" against all arrays
+  #   :merge_hash_arrays      DEFAULT: false
+  #      Set to true to merge hashes within arrays
+  #   :merge_debug            DEFAULT: false
+  #      Set to true to get console output of merge process for debugging
+  #
+  # Selected Options Details:
+  # :knockout_prefix => The purpose of this is to provide a way to remove elements
+  #   from existing Hash by specifying them in a special way in incoming hash
+  #    source = {:x => ['--1', '2']}
+  #    dest   = {:x => ['1', '3']}
+  #    dest.ko_deep_merge!(source)
+  #    Results: {:x => ['2','3']}
+  #   Additionally, if the knockout_prefix is passed alone as a string, it will cause
+  #   the entire element to be removed:
+  #    source = {:x => '--'}
+  #    dest   = {:x => [1,2,3]}
+  #    dest.ko_deep_merge!(source)
+  #    Results: {:x => ""}
+  # :unpack_arrays => The purpose of this is to permit compound elements to be passed
+  #   in as strings and to be converted into discrete array elements
+  #   irsource = {:x => ['1,2,3', '4']}
+  #   dest   = {:x => ['5','6','7,8']}
+  #   dest.deep_merge!(source, {:unpack_arrays => ','})
+  #   Results: {:x => ['1','2','3','4','5','6','7','8'}
+  #   Why: If receiving data from an HTML form, this makes it easy for a checkbox
+  #    to pass multiple values from within a single HTML element
+  #
+  # :merge_hash_arrays => merge hashes within arrays
+  #   source = {:x => [{:y => 1}]}
+  #   dest   = {:x => [{:z => 2}]}
+  #   dest.deep_merge!(source, {:merge_hash_arrays => true})
+  #   Results: {:x => [{:y => 1, :z => 2}]}
+  # 
+  # There are many tests for this library - and you can learn more about the features
+  # and usages of deep_merge! by just browsing the test examples
+  def self.deep_merge!(source, dest, options = {})
+    # turn on this line for stdout debugging text
+    merge_debug = options[:merge_debug] || false
+    overwrite_unmergeable = !options[:preserve_unmergeables]
+    knockout_prefix = options[:knockout_prefix] || nil
+    raise InvalidParameter, "knockout_prefix cannot be an empty string in deep_merge!" if knockout_prefix == ""
+    raise InvalidParameter, "overwrite_unmergeable must be true if knockout_prefix is specified in deep_merge!" if knockout_prefix && !overwrite_unmergeable
+    # if present: we will split and join arrays on this char before merging
+    array_split_char = options[:unpack_arrays] || false
+    # request that we sort together any arrays when they are merged
+    sort_merged_arrays = options[:sort_merged_arrays] || false
+    # request that arrays of hashes are merged together
+    merge_hash_arrays = options[:merge_hash_arrays] || false
+    di = options[:debug_indent] || ''
+    # do nothing if source is nil
+    return dest if source.nil?
+    # if dest doesn't exist, then simply copy source to it
+    if !(dest) && overwrite_unmergeable
+      dest = source; return dest
+    end
+
+    puts "#{di}Source class: #{source.class.inspect} :: Dest class: #{dest.class.inspect}" if merge_debug
+    if source.kind_of?(Hash)
+      puts "#{di}Hashes: #{source.inspect} :: #{dest.inspect}" if merge_debug
+      source.each do |src_key, src_value|
+        if dest.kind_of?(Hash)
+          puts "#{di} looping: #{src_key.inspect} => #{src_value.inspect} :: #{dest.inspect}" if merge_debug
+          if dest[src_key]
+            puts "#{di} ==>merging: #{src_key.inspect} => #{src_value.inspect} :: #{dest[src_key].inspect}" if merge_debug
+            dest[src_key] = deep_merge!(src_value, dest[src_key], options.merge(:debug_indent => di + '  '))
+          else # dest[src_key] doesn't exist so we want to create and overwrite it (but we do this via deep_merge!)
+            puts "#{di} ==>merging over: #{src_key.inspect} => #{src_value.inspect}" if merge_debug
+            # note: we rescue here b/c some classes respond to "dup" but don't implement it (Numeric, TrueClass, FalseClass, NilClass among maybe others)
+            begin
+              src_dup = src_value.dup # we dup src_value if possible because we're going to merge into it (since dest is empty)
+            rescue TypeError
+              src_dup = src_value
+            end
+            dest[src_key] = deep_merge!(src_value, src_dup, options.merge(:debug_indent => di + '  '))
+          end
+        else # dest isn't a hash, so we overwrite it completely (if permitted)
+          if overwrite_unmergeable
+            puts "#{di}  overwriting dest: #{src_key.inspect} => #{src_value.inspect} -over->  #{dest.inspect}" if merge_debug
+            dest = overwrite_unmergeables(source, dest, options)
+          end
+        end
+      end
+    elsif source.kind_of?(Array)
+      puts "#{di}Arrays: #{source.inspect} :: #{dest.inspect}" if merge_debug
+      # if we are instructed, join/split any source arrays before processing
+      if array_split_char
+        puts "#{di} split/join on source: #{source.inspect}" if merge_debug
+        source = source.join(array_split_char).split(array_split_char)
+        if dest.kind_of?(Array)
+          dest = dest.join(array_split_char).split(array_split_char)
+        end
+      end
+      # if there's a naked knockout_prefix in source, that means we are to truncate dest
+      if source.index(knockout_prefix)
+        dest = clear_or_nil(dest); source.delete(knockout_prefix)
+      end
+      if dest.kind_of?(Array)
+        if knockout_prefix
+          print "#{di} knocking out: " if merge_debug
+          # remove knockout prefix items from both source and dest
+          source.delete_if do |ko_item|
+            retval = false
+            item = ko_item.respond_to?(:gsub) ? ko_item.gsub(%r{^#{knockout_prefix}}, "") : ko_item
+            if item != ko_item
+              print "#{ko_item} - " if merge_debug
+              dest.delete(item)
+              dest.delete(ko_item)
+              retval = true
+            end
+            retval
+          end
+          puts if merge_debug
+        end
+        puts "#{di} merging arrays: #{source.inspect} :: #{dest.inspect}" if merge_debug
+        source_all_hashes = source.all? { |i| i.kind_of?(Hash) }
+        dest_all_hashes = dest.all? { |i| i.kind_of?(Hash) }
+        if merge_hash_arrays && source_all_hashes && dest_all_hashes
+          # merge hashes in lists
+          list = []
+          dest.each_index do |i|
+            list[i] = deep_merge!(source[i] || {}, dest[i],
+                                  options.merge(:debug_indent => di + '  '))
+          end
+          list += source[dest.count..-1] if source.count > dest.count
+          dest = list
+        else
+          dest = dest | source
+        end
+        dest.sort! if sort_merged_arrays
+      elsif overwrite_unmergeable
+        puts "#{di} overwriting dest: #{source.inspect} -over-> #{dest.inspect}" if merge_debug
+        dest = overwrite_unmergeables(source, dest, options)
+      end
+    else # src_hash is not an array or hash, so we'll have to overwrite dest
+      puts "#{di}Others: #{source.inspect} :: #{dest.inspect}" if merge_debug
+      dest = overwrite_unmergeables(source, dest, options)
+    end
+    puts "#{di}Returning #{dest.inspect}" if merge_debug
+    dest
+  end # deep_merge!
+
+  # allows deep_merge! to uniformly handle overwriting of unmergeable entities
+  def self.overwrite_unmergeables(source, dest, options)
+    merge_debug = options[:merge_debug] || false
+    overwrite_unmergeable = !options[:preserve_unmergeables]
+    knockout_prefix = options[:knockout_prefix] || false
+    di = options[:debug_indent] || ''
+    if knockout_prefix && overwrite_unmergeable
+      if source.kind_of?(String) # remove knockout string from source before overwriting dest
+        src_tmp = source.gsub(%r{^#{knockout_prefix}},"")
+      elsif source.kind_of?(Array) # remove all knockout elements before overwriting dest
+        src_tmp = source.delete_if {|ko_item| ko_item.kind_of?(String) && ko_item.match(%r{^#{knockout_prefix}}) }
+      else
+        src_tmp = source
+      end
+      if src_tmp == source # if we didn't find a knockout_prefix then we just overwrite dest
+        puts "#{di}#{src_tmp.inspect} -over-> #{dest.inspect}" if merge_debug
+        dest = src_tmp
+      else # if we do find a knockout_prefix, then we just delete dest
+        puts "#{di}\"\" -over-> #{dest.inspect}" if merge_debug
+        dest = ""
+      end
+    elsif overwrite_unmergeable
+      dest = source
+    end
+    dest
+  end
+
+  def self.clear_or_nil(obj)
+    if obj.respond_to?(:clear)
+      obj.clear
+    else
+      obj = nil
+    end
+    obj
+  end
+
+end # module DeepMerge

data/lib/capistrano-campout/defaults.yml

@@ -0,0 +1,6 @@
+pre_deploy:
+    message: "<%= campout_deployer %> is starting to deploy <%= application %> to <%= stage %>"
+post_deploy_success:
+    message: "<%= campout_deployer %> deployed <%= application %> to <%= stage %>"
+post_deploy_failure:
+    message: "The deploy of <%= application %> to <%= stage %> by <%= campout_deployer %> has failed."

data/lib/capistrano-campout/git_utils.rb

@@ -0,0 +1,74 @@
+# === COPYRIGHT:
+# Copyright (c) 2012 Jason Adam Young
+# === LICENSE:
+# see LICENSE file
+module Capistrano
+  module Campout
+    class GitUtils
+      
+      def initialize(path)
+        @path = path
+        if(localrepo)
+          return self
+        else
+          return nil
+        end
+      end
+    
+      def localrepo
+        if(@localrepo.nil?)
+          begin
+            @localrepo = Grit::Repo.new(@path)
+          rescue Grit::InvalidGitRepositoryError
+          end
+        end
+        @localrepo
+      end
+     
+      def user_name
+        if(localrepo)
+          git_config = Grit::Config.new(localrepo)
+          git_config.fetch('user.name')
+        else
+          nil
+        end
+      end
+      
+      def repository=(repository)
+        @repository = repository
+      end
+      
+      def github_url_for_repository
+        if(!@mogrified_repository)
+          if(@repository =~ /git@github.com/)
+            @mogrified_repository = @repository.dup
+            @mogrified_repository.gsub!(/git@/, 'http://')
+            @mogrified_repository.gsub!(/\.com:/,'.com/')
+            @mogrified_repository.gsub!(/\.git/, '')
+          end
+        end
+        @mogrified_repository
+      end
+      
+      def repository_is_github?
+        return (!github_url_for_repository.nil?)
+      end
+      
+      def github_compare_url(previous_revision, latest_revision)
+        if(repository_is_github?)
+          if(previous_revision != latest_revision)
+            "#{github_url_for_repository}/compare/#{previous_revision}...#{latest_revision}"
+          else
+            "#{github_url_for_repository}/commit/#{latest_revision}"
+          end
+        else
+          nil
+        end
+      end
+      
+    end
+  end
+end
+        
+        
+        

data/lib/capistrano-campout/logger.rb

@@ -0,0 +1,127 @@
+#
+# Original source from: https://github.com/engineyard/eycap/blob/master/lib/eycap/lib/ey_logger.rb
+# Copyright (c) 2008-2011 Engine Yard, released under the MIT License
+#
+require 'tmpdir'
+require 'fileutils'
+module Capistrano
+  
+  class Logger  
+    
+    def campout_log(level, message, line_prefix = nil)
+      CampoutLogger.log(level, message, line_prefix) if CampoutLogger.setup?
+      log_without_campout_logging(level, message, line_prefix)
+    end
+    
+    unless method_defined?(:log_without_campout_logging)
+      alias_method :log_without_campout_logging, :log 
+      alias_method :log, :campout_log
+    end
+    
+    def close
+      device.close if @needs_close
+      CampoutLogger.close if CampoutLogger.setup?
+    end
+  end
+  
+  class CampoutLogger
+    
+    # Sets up the CampoutLogger to begin capturing capistrano's logging.  You should pass the capistrano configuration
+    def self.setup(configuration, options = {})
+      @_configuration = configuration
+      @_log_path = options[:deploy_log_path] || Dir.tmpdir
+      @_log_path << "/" unless @_log_path =~ /\/$/
+      FileUtils.mkdir_p(@_log_path)
+      @_setup = true
+      @_success = true
+    end
+    
+    def self.log(level, message, line_prefix=nil)
+      return nil unless setup?
+      @release_name = @_configuration[:release_name] if @release_name.nil?
+      @_log_file_path = @_log_path + @release_name + ".log" unless @_log_file_path
+      @_deploy_log_file = File.open(@_log_file_path, "w") if @_deploy_log_file.nil?
+       
+      indent = "%*s" % [Logger::MAX_LEVEL, "*" * (Logger::MAX_LEVEL - level)]
+      message.each_line do |line|
+        if line_prefix
+          @_deploy_log_file << "#{indent} [#{line_prefix}] #{line.strip}\n"
+        else
+          @_deploy_log_file << "#{indent} #{line.strip}\n"
+        end
+      end
+    end
+    
+    def self.post_process      
+      unless ::Interrupt === $!
+        puts "\n\nPlease wait while the log file is processed\n"
+        # Should dump the stack trace of an exception if there is one
+        error = $!
+        unless error.nil?
+          @_deploy_log_file << error.message << "\n"
+          @_deploy_log_file << error.backtrace.join("\n")
+          @_success = false
+        end
+        self.close
+
+        hooks = [:any]
+        hooks << (self.successful? ? :success : :failure)
+        puts "Executing Post Processing Hooks"
+        hooks.each do |h|
+          @_post_process_hooks[h].each do |key|
+            @_configuration.parent.find_and_execute_task(key)
+          end
+        end
+        puts "Finished Post Processing Hooks"
+      end
+    end
+    
+    # Adds a post processing hook.  
+    #
+    # Provide a task name to execute.  These tasks are executed after capistrano has actually run its course. 
+    #
+    # Takes a key to control when the hook is executed.'
+    # :any - always executed
+    # :success - only execute on success
+    # :failure - only execute on failure
+    #
+    # ==== Example
+    #  Capistrano::CampoutLogger.post_process_hook( "campout:post_log", :any) 
+    #
+    def self.post_process_hook(task, key = :any)
+      @_post_process_hooks ||= Hash.new{|h,k| h[k] = []}
+      @_post_process_hooks[key] << task
+    end
+
+    def self.setup?
+      !!@_setup
+    end   
+    
+    def self.deploy_type
+      @_deploy_type
+    end
+    
+    def self.successful?
+      !!@_success
+    end
+    
+    def self.failure?
+      !@_success
+    end
+    
+    def self.log_file_path
+      @_log_file_path
+    end
+    
+    def self.remote_log_file_name
+      @_log_file_name ||= "deploy-#{@_configuration[:release_name]}-#{self.successful? ? "success" : "failure"}.log"
+    end
+    
+    def self.close
+      @_deploy_log_file.flush unless @_deploy_log_file.nil?
+      @_deploy_log_file.close unless @_deploy_log_file.nil?
+      @_setup = false
+    end
+    
+  end
+end

data/lib/capistrano-campout/options.rb

@@ -0,0 +1,149 @@
+#
+# The core of options.rb comes from rails_config, https://github.com/railsjedi/rails_config
+#
+# Copyright (c) 2010 Jacques Crocker, released under the MIT license
+# 
+#
+
+require 'ostruct'
+require 'yaml'
+require 'erb'
+
+module Capistrano
+  module Campout
+    module Sources
+      class YAMLSource
+
+        attr_accessor :path
+
+        def initialize(path)
+          @path = path
+        end
+
+        # returns a config hash from the YML file
+        def load
+          if @path and File.exists?(@path.to_s)
+            result = YAML.load(IO.read(@path.to_s))
+          end
+          result || {}
+        end
+
+      end
+    end
+  
+    class Options < OpenStruct
+      attr_accessor :defaults
+      
+      def valid?
+        # requires the following settings
+        # campfire:
+        #   domain:
+        #   token:
+        #   room:
+        
+        return false if(self.campfire.nil?)
+        return false if(self.campfire.domain.nil?)
+        return false if(self.campfire.token.nil?)
+        return false if(self.campfire.room.nil?)
+        return true
+      end
+  
+      def files=(*files)
+        if(!files.empty?)
+          @files = [files].flatten.compact.uniq
+        end
+      end
+      
+      def files
+        if(@files.nil? or @files.empty?)
+          @files = ["#{File.join(File.dirname(__FILE__), "defaults.yml").to_s}","./config/campout.yml","./config/campout.local.yml"]
+        end
+        @files
+      end
+    
+      def empty?
+        marshal_dump.empty?
+      end
+
+      def load_from_files(*files)
+        self.files=files
+        self.load!
+      end
+      
+      def reload_from_files(*files)
+        self.files=files
+        self.reload!
+      end
+    
+      def reset_sources!
+        self.files.each do |file|
+          source = (Sources::YAMLSource.new(file)) if file.is_a?(String)          
+          @config_sources ||= []
+          @config_sources << source
+        end
+      end
+
+      # look through all our sources and rebuild the configuration
+      def reload!
+        self.reset_sources!
+        conf = {}
+        @config_sources.each do |source|
+          source_conf = source.load
+
+          if conf.empty?
+            conf = source_conf
+          else
+            DeepMerge.deep_merge!(source_conf, conf, :preserve_unmergeables => false)
+          end
+        end
+
+        # swap out the contents of the OStruct with a hash (need to recursively convert)
+        marshal_load(__convert(conf).marshal_dump)
+
+        return self
+      end
+
+      alias :load! :reload!
+
+      def to_hash
+        result = {}
+        marshal_dump.each do |k, v|
+          result[k] = v.instance_of?(RailsConfig::Options) ? v.to_hash : v
+        end
+        result
+      end
+
+      def to_json(*args)
+        require "json" unless defined?(JSON)
+        to_hash.to_json(*args)
+      end
+
+      def merge!(hash)
+        current = to_hash
+        DeepMerge.deep_merge!(current, hash.dup)
+        marshal_load(__convert(hash).marshal_dump)
+        self
+      end
+    
+      protected
+
+      # Recursively converts Hashes to Options (including Hashes inside Arrays)
+      def __convert(h) #:nodoc:
+        s = self.class.new
+
+        h.each do |k, v|
+          s.new_ostruct_member(k)
+
+          if v.is_a?(Hash)
+            v = v["type"] == "hash" ? v["contents"] : __convert(v)
+          elsif v.is_a?(Array)
+            v = v.collect { |e| e.instance_of?(Hash) ? __convert(e) : e }
+          end
+
+          s.send("#{k}=".to_sym, v)
+        end
+        s
+      end
+    end
+  end
+end

data/lib/capistrano-campout/recipes/campout.rb

@@ -0,0 +1,49 @@
+# === COPYRIGHT:
+# Copyright (c) 2012 Jason Adam Young
+# === LICENSE:
+# see LICENSE file
+
+#
+# Post process hooks inspired by: https://github.com/engineyard/eycap/blob/master/lib/eycap/lib/ey_logger_hooks.rb
+# Copyright (c) 2008-2011 Engine Yard, released under the MIT License
+#
+
+Capistrano::Configuration.instance(:must_exist).load do
+  namespace :campout do
+    
+    ## no descriptions for the following tasks - meant to be hooked by capistrano
+    task :pre_announce do
+      campout_core.pre_announce(binding: binding)
+    end
+    
+    task :post_announce_success do
+      campout_core.post_announce_success(binding: binding, 
+                                         repository: repository, 
+                                         previous_revision: previous_revision, 
+                                         latest_revision: latest_revision)
+    end
+    
+    task :post_announce_failure do
+      campout_core.post_announce_failure(binding: binding)
+    end
+    
+    task :copy_log, :except => { :no_release => true} do
+      logger = Capistrano::CampoutLogger
+      run "mkdir -p #{shared_path}/deploy_logs"
+      put File.open(logger.log_file_path).read, "#{shared_path}/deploy_logs/#{logger.remote_log_file_name}"
+    end
+    
+    desc "Display campfire messages and actions based on current configuration"
+    task :will_do do
+      campout_core.will_do(binding: binding)
+    end
+    
+    task :settings do
+      y campout_core.settings
+    end
+  end
+end
+
+Capistrano::CampoutLogger.post_process_hook("campout:post_announce_success",:success)
+Capistrano::CampoutLogger.post_process_hook("campout:post_announce_failure",:failure)
+Capistrano::CampoutLogger.post_process_hook("campout:copy_log",:any)

data/lib/capistrano-campout/recipes/deploy.rb

@@ -0,0 +1,20 @@
+# === COPYRIGHT:
+# Copyright (c) 2012 Jason Adam Young
+# === LICENSE:
+# see LICENSE file
+
+#
+# Original source from: https://github.com/engineyard/eycap/blob/master/lib/eycap/recipes/deploy.rb
+# Copyright (c) 2008-2011 Engine Yard, released under the MIT License
+#
+
+Capistrano::Configuration.instance(:must_exist).load do
+  namespace :deploy do    
+    # This is here to hook into the logger for deploy tasks
+    before("deploy") do
+      Capistrano::CampoutLogger.setup(self)
+      at_exit{ Capistrano::CampoutLogger.post_process if Capistrano::CampoutLogger.setup? }
+    end
+  end
+end
+    

data/lib/capistrano-campout/version.rb

@@ -0,0 +1,5 @@
+module Capistrano
+  module Campout
+    VERSION = "0.0.1"
+  end
+end

data/lib/capistrano-campout.rb

@@ -0,0 +1,39 @@
+# === COPYRIGHT:
+# Copyright (c) 2012 Jason Adam Young
+# === LICENSE:
+# see LICENSE file
+require 'capistrano'
+require 'tinder'
+require 'grit'
+
+require 'capistrano-campout/logger'
+require 'capistrano-campout/version'
+require 'capistrano-campout/deep_merge' unless defined?(DeepMerge)
+require 'capistrano-campout/options'
+require 'capistrano-campout/git_utils'
+require 'capistrano-campout/core'
+
+module Capistrano
+  module Campout
+    def self.extended(configuration)
+      configuration.load do    
+        set :campout_core, Capistrano::Campout::Core.new
+        set :campout_deployer, campout_core.campout_deployer    
+      end
+    end
+  end
+end
+
+if Capistrano::Configuration.instance
+  Capistrano::Configuration.instance.extend(Capistrano::Campout)
+end
+
+Capistrano::Configuration.instance(:must_exist).load do
+  if(campout_core.settings.valid?)
+    # load the recipes
+    Dir.glob(File.join(File.dirname(__FILE__), '/capistrano-campout/recipes/*.rb')).sort.each { |f| load f }
+    before "deploy", "campout:pre_announce"
+  else
+    logger.info "The campout configuration is not valid. Make sure that the campfire settings are specified in the campout configuration file(s)"
+  end
+end

metadata

@@ -0,0 +1,100 @@
+--- !ruby/object:Gem::Specification
+name: capistrano-campout
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Jason Adam Young
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-04-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: capistrano
+  requirement: &70114418631680 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '2.11'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70114418631680
+- !ruby/object:Gem::Dependency
+  name: tinder
+  requirement: &70114418615660 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70114418615660
+- !ruby/object:Gem::Dependency
+  name: grit
+  requirement: &70114418614880 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '2.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70114418614880
+description: ! "    Capistrano::Campout is a gem extension to capistrano to post/speak
+  messages and paste logs from a capistrano deployment \n    to a campfire room. Settings
+  are configurable using ERB in a \"config/campout.yml\" or \"config/campout.local.yml\"
+  file. \n    Capistrano::Campout will a speak a pre-deployment message, and a post-deployment
+  success or failure message. Event sounds\n    are also supported.\n"
+email:
+- jay@outfielding.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- capistrano-campout.gemspec
+- lib/capistrano-campout.rb
+- lib/capistrano-campout/cap_tasks.rb
+- lib/capistrano-campout/core.rb
+- lib/capistrano-campout/deep_merge.rb
+- lib/capistrano-campout/defaults.yml
+- lib/capistrano-campout/git_utils.rb
+- lib/capistrano-campout/logger.rb
+- lib/capistrano-campout/options.rb
+- lib/capistrano-campout/recipes/campout.rb
+- lib/capistrano-campout/recipes/deploy.rb
+- lib/capistrano-campout/version.rb
+homepage: https://github.com/jasonadamyoung/capistrano-campout
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+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
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.17
+signing_key: 
+specification_version: 3
+summary: Post messages and paste logs from a capistrano deployment to a campfire room
+test_files: []