nogara-capistrano-conditional 0.0.3

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    MWMyZTk1ZGVkMDhlNTgyYTMzODRlMThjOGQwMTMzYmQwMmE2OGY0Mw==
+  data.tar.gz: !binary |-
+    ZGJlYzRjZDcxZjk3ZTZkYjc1OGE3ZDg4NDFhY2E5Njc0MDcwYWJmMA==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    YjY3MTY4N2RiMDI0M2NmOWJjNzllYTcxN2Q1MjY3NjQ1ZTkxMDllMmMwYjU4
+    MTU0NWM0MDc3MTM0NTdhODgxZDQ5NTQ2NzdjNWM4YTUwNDg2M2VkYTIyZDEw
+    ZTc3ZWE3MDBmNmFiYjI1MWY1NDkyYWZmNzg1MTJlZjgwYzBiOTE=
+  data.tar.gz: !binary |-
+    OTUyNjQ1M2E1MTUxODUyZTVjMTYzNTE4ZjA2NzMxYTYxMTYzYzNjZWZiZDc2
+    OTgyZjZjMDYyODY3YjA0NTY3YTYxMTMyMDg5NTU1N2Y5MWQxMzZiNTEwN2Ri
+    ZjRhOGE5MGFhMmZlY2RiODYwZTJhOTI0NjZlNWI1MmY0M2M1MmQ=

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

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

data/README.md

@@ -0,0 +1,99 @@
+# capistrano-conditional
+
+This gem extends capistrano deployments to allow certain tasks to only be run under certain conditions -- i.e. conditionally.
+
+## Installation
+
+Add to your Gemfile:
+
+    group :development do
+      gem 'capistrano-conditional', :require => false # <-- This is important!
+    end
+
+And then modify your deploy.rb to include this at the top:
+
+    require "capistrano-conditional"
+
+## Requirements
+
+Your application must already be using capistrano for deployments, and (for now at least) you need to be using git.
+
+## Usage Instructions
+
+<code>capistrano-conditional</code> adds logic to be run before <code>cap deploy</code> or <code>cap deploy:migrations</code> that compares the local (to be deployed) code with the existing remote (currently deployed) code and lists all files that will be updated by the current deploy.  It then checks the list of conditional statements that you've provided and runs any that you want run -- e.g. if you're using [whenever](https://github.com/javan/whenever) and you only want to run the <code>deploy:update_crontab</code> task if <code>config/schedule.rb</code> has been changed, you'd add a block like this to your deploy.rb:
+
+    ConditionalDeploy.register :whenever, :watchlist => 'config/schedule.rb' do
+      after "deploy:symlink", "deploy:update_crontab"
+    end
+
+This example registers a conditional named "whenever" (names aren't programmatically important, but they're used to report what's going to be run at the beginning of each deploy).  The contents of the block will be run only if the list of changed files includes a path that matches <code>config/schedule.rb</code>.
+
+### Available Conditions
+
+There are currently four logic conditions available (well, five, but <code>:watchlist</code> is just an alias for <code>:any_match</code>):
+
+  * <code>:any_match</code> => file_list
+  * <code>:none_match</code> => file_list
+  * <code>:if</code> => Proc
+  * <code>:unless</code> => Proc
+  
+Where file_list is either a string or an array of strings which will be <em>matched</em> against the list of changed filenames from git (so <code>:any_match => ['db/migrate']</code> would be true if ANY migration file was added, modified, or deleted).
+
+<code>:any_match</code> (aliased as <code>:watchlist</code>) executes the block if ANY of the provided strings match ANY of file paths git reports changed.
+
+<code>:none_match</code> executes the block if NONE of the provided strings match ANY of file paths git reports changed.
+
+If you need more custom control, <code>:if</code> and <code>:unless</code> expect a Proc (which will be passed the list of changed files, if one argument is expected, or the list of changes and the git object itself, if two arguments are expected and you really want to dive into things yourself).
+
+## Example Usage
+
+    ConditionalDeploy.register :whenever, :watchlist => 'config/schedule.rb' do
+      after "deploy:symlink", "deploy:update_crontab"
+    end
+
+    ConditionalDeploy.register :sphinx, :watchlist => ['db/schema.rb', 'db/migrate'] do
+      before "deploy:update_code",  "thinking_sphinx:stop"
+      before "deploy:start",        "thinking_sphinx:start"
+      before "deploy:restart",      "thinking_sphinx:start"
+    end
+
+    ConditionalDeploy.register :jammit, :watchlist => ['public/images/embed', 'public/stylesheets', 'public/javascripts', 'public/assets', 'config/assets.yml'] do
+      after 'deploy:symlink', 'deploy:rebuild_assets'
+    end
+
+    # Restart the resque workers unless the only changes were to static assets, views, or controllers.
+    ConditionalDeploy.register(:resque, :unless => lambda { |changed| changed.all?{|f| f['public/'] || f['app/controllers/'] || f['app/views/'] } }) do
+      before "deploy:restart", "resque:workers:restart"
+    end
+    
+    # ... note that you still have to actually DEFINE the tasks laid out above (e.g. deploy:update_crontab)
+    
+
+I've got <code>cap deploy</code> in muscle memory, and I used to find myself forgetting to run <code>cap deploy:migrations</code> until after I tested the new changes and found staging wasn't working right.  I now add the following code to my apps, so I never have to worry about it again:
+    
+    if ARGV.any?{|v| v['deploy:migrations']} # If running deploy:migrations
+      # If there weren't any changes to migrations or the schema file, then abort the deploy
+      ConditionalDeploy.register :unneeded_migrations, :none_match => ['db/schema.rb', 'db/migrate'] do
+        abort "You're running migrations, but it doesn't look like you need to!"
+      end
+    else # If NOT running deploy:migrations
+      # If there were changes to migration files, run migrations as part of the deployment
+      ConditionalDeploy.register :forgotten_migrations, :any_match => ['db/schema.rb', 'db/migrate'], :msg => "Forgot to run migrations? It's cool, we'll do it for you." do
+        after "deploy:update_code", "deploy:migrate"
+      end  
+    end
+
+Since I use it on every project, I've wrapped that logic up in a single command:
+
+    ConditionalDeploy.monitor_migrations(self)
+  
+## Advanced Usage
+
+By default <code>capistrano-conditional</code> will abort the deployment if you have uncommited changes in your working directory.  You can skip this check on an individual run by setting the ALLOW_UNCOMMITED environment variable (e.g. <code>cap deploy ALLOW_UNCOMMITTED=1</code>).
+
+If you need to force a particular conditional to run, you can also do that via the environment.  Given the examples above, if you want to run the conditional named <code>whenever</code> even though config/schedule.rb hasn't been changed, just run <code>cap deploy RUN_WHENEVER=1</code>. Similarly, if you needed to skip the <code>whenever</code> conditional which would otherwise be run, you can use <code>cap deploy SKIP_WHENEVER=1</code>.
+
+## License
+
+Copyright &copy; 2011 [Deviantech, Inc.](http://www.deviantech.com) and released under the MIT license.
+

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/capistrano-conditional.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "capistrano-conditional/version"
+
+Gem::Specification.new do |s|
+  s.name        = "nogara-capistrano-conditional"
+  s.version     = Capistrano::Conditional::VERSION
+  s.authors     = ["Kali Donovan"]
+  s.email       = ["kali@deviantech.com"]
+  s.homepage    = ""
+  s.summary     = %q{Adds support for conditional deployment tasks in capistrano}
+  s.description = %q{Allows making tasks for git-based projects conditional based on the specific files to be deployed.}
+
+  s.rubyforge_project = "capistrano-conditional"
+
+  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"]
+
+  # specify any dependencies here; for example:
+  # s.add_development_dependency "rspec"
+  s.add_runtime_dependency "git"
+  s.add_runtime_dependency "capistrano"
+end

data/lib/capistrano-conditional.rb

@@ -0,0 +1,5 @@
+require "capistrano-conditional/version"
+require 'git'
+require "capistrano-conditional/unit"
+require "capistrano-conditional/deploy"
+require "capistrano-conditional/integration"

data/lib/capistrano-conditional/deploy.rb

@@ -0,0 +1,101 @@
+# This class handles the logic associated with checking if each conditional
+# statement applies to a given deploy and, if so, applying them.
+#
+# The only publicly-useful method is <em>ConditionalDeploy.register</em>, which
+# is used in deploy.rb to add conditional elements (see README for details).
+class ConditionalDeploy
+
+  @@conditionals = []
+
+  def self.register(name, opts, &block)
+    raise("Already added a conditional with that name") if @@conditionals.any?{|c| c.name == name}
+    @@conditionals << Capistrano::Conditional::Unit.new(name, opts, block)
+  end
+
+  def self.monitor_migrations(context)
+    if ARGV.any?{|v| v['deploy:migrations']} # If running deploy:migrations
+      # If there weren't any changes to migrations or the schema file, then abort the deploy
+      ConditionalDeploy.register :unneeded_migrations, :none_match => ['db/schema.rb', 'db/migrate'] do
+        context.send :abort, "You're running migrations, but it doesn't look like you need to!"
+      end
+    else # If NOT running deploy:migrations
+      # If there were changes to migration files, run migrations as part of the deployment
+      ConditionalDeploy.register :forgotten_migrations, :any_match => ['db/schema.rb', 'db/migrate'], :msg => "Forgot to run migrations? It's cool, we'll do it for you." do
+        context.after "deploy:update_code", "deploy:migrate"
+      end  
+    end    
+  end
+
+  def self.apply_conditions!(deployed)
+    conditional = self.new(deployed)
+    conditional.ensure_local_up_to_date
+    conditional.screen_conditionals
+    conditional.report_plan
+    conditional.run_conditionals
+  end
+
+
+
+  def initialize(compare_to = 'HEAD^')
+    @logger = Capistrano::Logger.new(:output => STDOUT)
+    @logger.level = Capistrano::Logger::MAX_LEVEL
+    
+    @verbose = true
+    @git = Git.open('.')
+    @last_deployed = @git.object(compare_to)
+    @diff = @git.diff('HEAD', compare_to)
+    @changed = @diff.stats[:files].keys.sort
+    @to_run = []
+  end
+
+  def ensure_local_up_to_date
+    return true if ENV['ALLOW_UNCOMMITTED']
+    s = @git.status
+    no_changes = %w(changed added deleted).all? { |attrib| s.send(attrib).empty? }
+
+    unless no_changes
+      abort "\nYour working copy contains local changes not yet committed to git. \nPlease commit all changes before deploying.\n\n"
+    end
+  end
+
+  def report_plan
+    def log(text = "\n", level = Capistrano::Logger::TRACE)
+      @logger.log(level, text, "Conditional")
+    end
+    
+    log
+    log "Conditional Deployment Report:", Capistrano::Logger::IMPORTANT
+    log
+    log "\tLast deployed commit: #{@last_deployed.message}", Capistrano::Logger::DEBUG
+    log
+    log "\tFiles Modified:", Capistrano::Logger::DEBUG
+    @changed.each {|f| log "\t\t- #{f}"}
+    log
+    log "\tConditional Runlist:", Capistrano::Logger::DEBUG
+    if @to_run.empty?
+      log "\t\t* No conditional tasks have been added"
+    else
+      @to_run.each do |job|
+        out = job.message ? "#{job.name} (#{job.message})" : job.name
+        log "\t\t* Running #{out}"
+      end
+    end
+    log
+  end
+
+  def screen_conditionals
+    @@conditionals.each do |job|
+      force = job.name && ENV["RUN_#{job.name.to_s.upcase}"]
+      skip  = job.name && ENV["SKIP_#{job.name.to_s.upcase}"]
+      next unless force || job.applies?(@changed)
+      next if skip
+      @to_run << job
+    end
+  end
+  
+  def run_conditionals
+    @to_run.each do |job|
+      job.block.call
+    end
+  end
+end

data/lib/capistrano-conditional/integration.rb

@@ -0,0 +1,29 @@
+Capistrano::Configuration.instance(:must_exist).load do
+  abort "\ncapistrano-conditional is not compatible with Capistrano 1.x\n" unless respond_to?(:namespace)
+  abort "\nGit is not defined (are you in a git repository, with the Git gem installed?)\n" unless defined?(Git)
+
+  namespace :conditional do
+    desc "Initializes the conditional deployment functionality"
+    task :apply do
+      deployed_hash = capture("cat #{current_path}/REVISION").strip
+      ConditionalDeploy.apply_conditions!( deployed_hash )
+    end
+    
+    desc "Tests to be sure that the newest local and remote git commits match"
+    task :ensure_latest_git do
+      remote = capture("cd #{shared_path}/cached-copy && git log --format=oneline -n 1", :pty => false)
+      local = run_locally("git log --format=oneline -n 1")
+      
+      unless local == remote
+        abort("\nLocal and remote git repositories have different HEADs:\n    Local: #{local}    Remote: #{remote}\n    Make sure you've committed your latest changes, or else pull down the remote updates and try again\n")
+      end
+    end
+  end
+
+  # Ensure deploys apply conditional elements before running the rest of the tasks
+  before 'deploy', 'conditional:apply'
+  before 'deploy:migrations', 'conditional:apply'
+  
+  # Abort deployment if mismatch between local and remote git repositories
+  after 'deploy:update_code', 'conditional:ensure_latest_git'
+end

data/lib/capistrano-conditional/unit.rb

@@ -0,0 +1,71 @@
+module Capistrano
+  module Conditional
+    # Stores the actual conditionals added by the user, including under
+    # what conditions the conditional should be applied (<em>conditions</em>)
+    # and what to do if that's the case (<em>block</em>).
+    #
+    # Created from <em>ConditionalDeploy.register</em>, the end user should
+    # never need to interact with it directly.
+    class Unit
+      attr_accessor :name, :message, :conditions, :block
+
+      def initialize(name, opts, block)
+        @name = name
+        @message = opts.delete(:msg)
+        @block = block
+        @conditions = {}
+        opts.each do |k,v|
+          @conditions[k] = v
+        end
+      end
+
+      # Currently supported options: any_match (aliased to watchlist), none_match, if, unless
+      def applies?(changed)
+        @changed = changed
+        any_match_applies? && none_match_applies? && if_applies? && unless_applies?
+      end  
+
+      protected
+  
+        def any_match_applies?
+          any_files_match?(:any_match) && any_files_match?(:watchlist)
+        end
+        
+        def none_match_applies?
+          Array(conditions[:none_match]).all? do |watched| 
+            !@changed.any? { |path| path[watched] }
+          end
+        end
+    
+        def if_applies?
+          return true if conditions[:if].nil? 
+          condition_true?(:if)
+        end
+    
+        def unless_applies?
+          return true if conditions[:unless].nil?
+          !condition_true?(:unless)
+        end
+        
+        
+        
+        def any_files_match?(key)
+          return true unless conditions[key]
+          Array(conditions[key]).any? do |watched| 
+            @changed.any? { |path| path[watched] }
+          end
+        end
+        
+        def condition_true?(label)
+          c = conditions[label]
+          case c.arity
+          when 0 then c.call
+          when 1 then c.call(@changed)
+          else 2 
+            c.call(@changed, @git)
+          end
+        end 
+        
+    end 
+  end
+end

data/lib/capistrano-conditional/version.rb

@@ -0,0 +1,5 @@
+module Capistrano
+  module Conditional
+    VERSION = "0.0.3"
+  end
+end

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification
+name: nogara-capistrano-conditional
+version: !ruby/object:Gem::Version
+  version: 0.0.3
+platform: ruby
+authors:
+- Kali Donovan
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-05-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: git
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: capistrano
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Allows making tasks for git-based projects conditional based on the specific
+  files to be deployed.
+email:
+- kali@deviantech.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- README.md
+- Rakefile
+- capistrano-conditional.gemspec
+- lib/capistrano-conditional.rb
+- lib/capistrano-conditional/deploy.rb
+- lib/capistrano-conditional/integration.rb
+- lib/capistrano-conditional/unit.rb
+- lib/capistrano-conditional/version.rb
+homepage: ''
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: capistrano-conditional
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: Adds support for conditional deployment tasks in capistrano
+test_files: []