capistrano-wp 0.4.1

data/lib/crowdfavorite/support/capistrano_extensions.rb

@@ -0,0 +1,85 @@
+require 'tempfile'
+
+# These methods are used by recap tasks to run commands and detect when files have changed
+# as part of a deployments
+
+module CrowdFavorite::Support::CapistranoExtensions
+  # Run a command as the given user
+  def as_user(user, command, pwd = deploy_to)
+    sudo "su - #{user} -c 'cd #{pwd} && #{command}'"
+  end
+
+  # Run a command as root
+  def as_root(command, pwd = deploy_to)
+    as_user 'root', command, pwd
+  end
+
+  # Run a command as the application user
+  def as_app(command, pwd = deploy_to)
+    as_user application_user, command, pwd
+  end
+
+  # Put a string into a file as the application user
+  def put_as_app(string, path)
+    put string, "/tmp/cf-put-as-app"
+    as_app "cp /tmp/cf-put-as-app #{path} && chmod g+rw #{path}", "/"
+  ensure
+    run "rm /tmp/cf-put-as-app"
+  end
+
+  def editor
+    ENV['DEPLOY_EDITOR'] || ENV['EDITOR']
+  end
+
+  # Edit a file on the remote server, using a local editor
+  def edit_file(path)
+    if editor
+      as_app "touch #{path} && chmod g+rw #{path}"
+      local_path = Tempfile.new('deploy-edit').path
+      get(path, local_path)
+      CrowdFavorite::Support::ShellCommand.execute_interactive("#{editor} #{local_path}")
+      File.read(local_path)
+    else
+      abort "To edit a remote file, either the EDITOR or DEPLOY_EDITOR environment variables must be set"
+    end
+  end
+
+  # Run a git command in the `deploy_to` directory
+  def git(command)
+    run "cd #{deploy_to} && umask 002 && sg #{application_group} -c \"git #{command}\""
+  end
+
+  # Capture the result of a git command run within the `deploy_to` directory
+  def capture_git(command)
+    capture "cd #{deploy_to} && umask 002 && sg #{application_group} -c 'git #{command}'"
+  end
+
+  def exit_code(command)
+    capture("#{command} > /dev/null 2>&1; echo $?").strip
+  end
+
+  def exit_code_as_app(command, pwd = deploy_to)
+    capture(%|sudo -p 'sudo password: ' su - #{application_user} -c 'cd #{pwd} && #{command} > /dev/null 2>&1'; echo $?|).strip
+  end
+
+  # Find the latest tag from the repository.  As `git tag` returns tags in order, and our release
+  # tags are timestamps, the latest tag will always be the last in the list.
+  def latest_tag_from_repository
+    result = capture_git("tag | tail -n1").strip
+    result.empty? ? nil : result
+  end
+
+  # Does the given file exist within the deployment directory?
+  def deployed_file_exists?(path, root_path = deploy_to)
+    exit_code("cd #{root_path} && [ -f #{path} ]") == "0"
+  end
+
+  # Has the given path been created or changed since the previous deployment?  During the first
+  # successful deployment this will always return true.
+  def deployed_file_changed?(path)
+    return true unless latest_tag
+    exit_code("cd #{deploy_to} && git diff --exit-code #{latest_tag} origin/#{branch} #{path}") == "1"
+  end
+
+  Capistrano::Configuration.send :include, self
+end

data/lib/crowdfavorite/support/namespace.rb

@@ -0,0 +1,47 @@
+require 'capistrano'
+require 'crowdfavorite/support/capistrano_extensions'
+
+# This module is used to capture the definition of capistrano tasks, which makes it
+# easier to test the behaviour of specific tasks without loading everything. If you
+# are writing tests for a collection of tasks, you should put those tasks in a module
+# and extend that module with `CrowdFavorite::Support::Namespace.
+#
+# You can look at some of the existing tasks (such as [env](../tasks/env.html)) and
+# its corresponding specs for an example of this in practice.
+#
+# You should not need to use this module directly when using recap to deploy.
+
+module CrowdFavorite::Support::Namespace
+  def self.default_config
+    @default_config
+  end
+
+  def self.default_config=(config)
+    @default_config = config
+  end
+
+  if Capistrano::Configuration.instance
+    self.default_config = Capistrano::Configuration.instance(:must_exist)
+  end
+
+  def capistrano_definitions
+    @capistrano_definitions ||= []
+  end
+
+  def namespace(name, &block)
+    capistrano_definitions << Proc.new do
+      namespace name do
+        instance_eval(&block)
+      end
+    end
+
+    load_into(CrowdFavorite::Support::Namespace.default_config) if CrowdFavorite::Support::Namespace.default_config
+  end
+
+  def load_into(configuration)
+    configuration.extend(self)
+    capistrano_definitions.each do |definition|
+      configuration.load(&definition)
+    end
+  end
+end

data/lib/crowdfavorite/tasks/localchanges.rb

@@ -0,0 +1,230 @@
+require 'crowdfavorite/tasks'
+
+module CrowdFavorite::Tasks::LocalChanges
+  extend CrowdFavorite::Support::Namespace
+
+  namespace :cf do
+    def _cset(name, *args, &block)
+      unless exists?(name)
+        set(name, *args, &block)
+      end
+    end
+
+    _cset(:comparison_target) { current_release rescue File.dirname(release_path) }
+    _cset(:hash_creation) { 
+      # Find out what hashing mechanism we can use - shasum, sha1sum, openssl, or just an ls command.
+      # Unfortunate double-call of which handles some systems which output an error message on stdout
+      # when the program cannot be found.
+      creation = capture('((which shasum >/dev/null 2>&1 && which shasum) || (which sha1sum >/dev/null 2>&1 && which sha1sum) || (which openssl >/dev/null 2>&1 && which openssl) || echo "ls -ld")').to_s.strip
+      if creation.match(/openssl$/)
+        "#{creation} sha1 -r"
+      end
+      creation
+    }
+
+    _cset(:hash_directory) { shared_path }
+    _cset(:hash_suffix) { "_hash" }
+    _cset(:hash_compare_suffix) { "compare" }
+    _cset(:hashes) { capture("ls -xt #{File.join(hash_directory, '*' + hash_suffix)}").split.reverse }
+
+
+    def _snapshot_exists(path)
+        retcode = (capture("test -f " + Shellwords::escape(path) + "; echo $?").to_s.strip.to_i)
+        return retcode == 0 ? true : false
+    end
+
+    def _hash_path(release, extra = "")
+      File.join(hash_directory, release + hash_suffix + extra)
+    end
+
+    namespace :localchanges do
+      task :snapshot_deploy, :except => { :no_release => true } do
+        set(:snapshot_target, latest_release)
+        snapshot
+        unset(:snapshot_target)
+      end
+
+      desc "Snapshot the current release for later change detection."
+      task :snapshot, :except => { :no_release => true } do
+        target_release = File.basename(fetch(:snapshot_target, comparison_target))
+
+        target_path = File.join(releases_path, target_release)
+        default_hash_path = _hash_path(target_release) # File.join(shared_path, target_release + "_hash")
+        hash_path = fetch(:snapshot_hash_path, default_hash_path)
+
+        snapshot_exists = _snapshot_exists(hash_path)
+        
+        if snapshot_exists and !fetch(:snapshot_force, false)
+          logger.info "A snapshot for release #{target_release} already exists."
+          next
+        end
+
+        run("find " + Shellwords::escape(target_path) + " -name .git -prune -o -name .svn -prune -o -type f -print0 | xargs -0 #{hash_creation} > " + Shellwords::escape(hash_path))
+
+      end
+
+      desc "Call this before a deploy to continue despite local changes made on the server."
+      task :allow_differences do
+        set(:snapshot_allow_differences, true)
+      end
+
+      task :forbid_differences do
+        set(:snapshot_allow_differences, false)
+      end
+
+      def _do_snapshot_compare()
+        if releases.length == 0
+          logger.info "no current release"
+          return false
+        end
+        release_name = File.basename(current_release)
+        set(:snapshot_target, current_release)
+        default_hash_path = _hash_path(release_name) # File.join(shared_path, release_name + "_hash")
+        snapshot_exists = _snapshot_exists(default_hash_path)
+        if !snapshot_exists
+          logger.info "no previous snapshot to compare against"
+          return false
+        end
+        set(:snapshot_hash_path, _hash_path(release_name, hash_compare_suffix)) # File.join(shared_path, release_name + "_hash_compare"))
+        set(:snapshot_force, true)
+        snapshot
+
+        # Hand-tooled diff-parsing - handles either shasum-style or ls -ld output
+        # Hashes store filename => [host, host, host]
+        left = {}
+        right = {}
+        changed = {}
+        run("diff " + default_hash_path + " " + snapshot_hash_path + " || true") do |channel, stream, data|
+          data.each_line do |line|
+            line.strip!
+            if line.match(/^\s*[<>]/)
+              parts = line.split(/\s+/)
+              if hash_creation.match(/ls -ld/)
+                # > -rw-rw-r-- 1 example example 41 Sep 19 14:58 index.php
+                parts.slice!(0, 9)
+              else
+                # < 198ed94e9f1e5c69e159e8ba6d4420bb9c039715  index.php
+                parts.slice!(0,2)
+              end
+
+              bucket = line.match(/^\s*</) ? left : right
+              filename = parts.join('')
+
+              bucket[filename] ||= []
+              bucket[filename].push(channel[:host])
+            end
+          end
+        end
+        if !(left.empty? && right.empty?)
+          left.each do |filename, servers|
+            if right.has_key?(filename)
+              servers.each do |host|
+                if right[filename].delete(host)
+                  changed[filename] ||= []
+                  changed[filename].push(host)
+                  left[filename].delete(host)
+                end
+              end
+
+              left.delete(filename) if left[filename].empty?
+              right.delete(filename) if right[filename].empty?
+            end
+          end
+        end
+
+        unset(:snapshot_target)
+        unset(:snapshot_hash_path)
+        unset(:snapshot_force)
+        return {:left => left, :right => right, :changed => changed}
+      end
+
+      def _do_snapshot_diff(results, format = :full)
+        if !results
+          return false
+        end
+        if results[:left].empty? && results[:right].empty? && results[:changed].empty?
+          return false
+        end
+
+        if format == :basic || !(fetch(:strategy).class <= Capistrano::Deploy::Strategy.new(:remote).class)
+          logger.important "deleted: " + results[:left].inspect
+          logger.important "created: " + results[:right].inspect
+          logger.important "changed: " + results[:changed].inspect
+          return true
+        end
+
+        ## TODO: improve diff handling for remote_cache with .git copy_excluded
+        ## TODO: improve diff handling for remote_cache with .git not copy_excluded
+        ## TODO: improve diff handling for remote_cache with .svn copy_excluded
+        ## TODO: improve diff handling for remote_cache with .svn not copy_excluded
+        logger.important "deleted: " + results[:left].inspect
+        logger.important "created: " + results[:right].inspect
+        logger.important "changed: " + results[:changed].inspect
+        return true
+
+        todostuff = <<-'EOTODO'
+        File.join(shared_path, configuration[:repository_cache] || "cached-copy")
+        if fetch(:scm) == :git
+          if fetch(:copy_exclude, []).include?(".git")
+            run("echo 'gitdir: #{}
+
+        end
+
+
+        run("diff " + default_hash_path + " " + snapshot_hash_path + " || true") do |channel, stream, data|
+          data.each_line do |line|
+            line.strip!
+            if line.match(/^\s*[<>]/)
+              parts = line.split(/\s+/)
+              if hash_creation.match(/ls -ld/)
+                # > -rw-rw-r-- 1 example example 41 Sep 19 14:58 index.php
+                parts.slice!(0, 9)
+              else
+                # < 198ed94e9f1e5c69e159e8ba6d4420bb9c039715  index.php
+                parts.slice!(0,2)
+              end
+
+              bucket = line.match(/^\s*</) ? left : right
+              filename = parts.join('')
+
+              bucket[filename] ||= []
+              bucket[filename].push(channel[:host])
+            end
+          end
+        end
+        logger.important "oh hey, fully featured"
+        return true
+        EOTODO
+      end
+
+      desc "Check the current release for changes made on the server; abort if changes are detected."
+      task :compare, :except => { :no_release => true } do
+        results = _do_snapshot_compare()
+        if _do_snapshot_diff(results, :basic)
+          abort("Aborting: local changes detected in current release") unless fetch(:snapshot_allow_differences, false)
+          logger.important "Continuing deploy despite differences!"
+        end
+      end
+
+      desc "Check the current release for changes made on the server (and return detailed changes, if using a remote-cached git repo).  Does not abort on changes."
+      task :diff, :except => { :no_release => true } do
+        results = _do_snapshot_compare()
+        _do_snapshot_diff(results, :full)
+      end
+
+      task :cleanup, :except => { :no_release => true } do
+        count = fetch(:keep_releases, 5).to_i
+        if count >= hashes.length
+          logger.info "no old hashes to clean up"
+        else
+          logger.info "keeping #{count} of #{hashes.length} release hashes"
+          hashpaths = (hashes - hashes.last(count)).map{ |thehash|
+            File.join(hash_directory, thehash) + " " + File.join(hash_directory, thehash + hash_compare_suffix)
+          }.join(" ")
+          try_sudo "rm -f #{hashpaths}"
+        end
+      end
+    end
+  end
+end
+

data/lib/crowdfavorite/tasks/wordpress.rb

@@ -0,0 +1,247 @@
+require 'crowdfavorite/tasks'
+require 'Shellwords'
+
+module CrowdFavorite::Tasks::WordPress
+  extend CrowdFavorite::Support::Namespace
+  def _combine_filehash base, update
+    if update.respond_to? :has_key?
+      update = [update]
+    end
+    new = {}
+    new.merge!(base)
+    update.each do |update_hash|
+      new.merge!(update_hash)
+    end
+    new
+  end
+  namespace :cf do
+    def _cset(name, *args, &block)
+      unless exists?(name)
+        set(name, *args, &block)
+      end
+    end
+
+    _cset :copy_exclude, [
+      ".git", ".gitignore", ".gitmodules",
+      ".DS_Store", ".svn", 
+      "Capfile", "/config",
+      "capinfo.json",
+    ]
+
+    # wp_symlinks are symlinked from the shared directory into the release.
+    # Key is the shared file; value is the target location.
+    # :wp_symlinks overwrites :base_wp_symlinks; an empty target location
+    # means to skip linking the file.
+    _cset :base_wp_symlinks, {
+      "cache" => "wp-content/cache",
+      "uploads" => "wp-content/uploads",
+      "blogs.dir" => "wp-content/blogs.dir",
+    }
+
+    _cset :wp_symlinks, {}
+
+    # wp_configs are copied from the shared directory into the release.
+    # Key is the shared file; value is the target location.
+    # :wp_configs overwrites :base_wp_configs; an empty target location
+    # means to skip copying the file.
+    _cset :base_wp_configs, {
+      "db-config.php" => "wp-content/",
+      "advanced-cache.php" => "wp-content/",
+      "object-cache.php" => "wp-content/",
+      "*.html" => "/",
+    }
+
+    _cset :wp_configs, {}
+
+    # stage_specific_overrides are uploaded from the repo's config 
+    # directory, if they exist for that stage.  Files are named
+    # 'STAGE-filename.txt' locally and copied to 'filename.txt'
+    # on deploy for that stage.
+    # Key is the local file; value is the target location.
+    # :stage_specific_overrides overwrites :base_stage_specific_overrides; 
+    # an empty target location means to skip uploading the file.
+    _cset :base_stage_specific_overrides, {
+      "local-config.php" => "local-config.php",
+      ".htaccess" => ".htaccess"
+    }
+
+    _cset :stage_specific_overrides, {}
+
+    before   "deploy:finalize_update", "cf:wordpress:generate_config"
+    after    "deploy:finalize_update", "cf:wordpress:touch_release"
+    after    "cf:wordpress:generate_config", "cf:wordpress:link_symlinks"
+    after    "cf:wordpress:link_symlinks", "cf:wordpress:copy_configs"
+    after    "cf:wordpress:copy_configs", "cf:wordpress:install"
+    after    "cf:wordpress:install", "cf:wordpress:do_stage_specific_overrides"
+    namespace :wordpress do
+
+      namespace :install do
+
+        desc <<-DESC
+              [internal] Installs WordPress with a remote svn cache
+        DESC
+        task :with_remote_cache, :except => { :no_release => true } do
+          wp = fetch(:wordpress_version, "trunk")
+          wp_target = fetch(:wp_path, release_path)
+          wp_stage = File.join(shared_path, "wordpress", wp)
+          # check out cache of wordpress code
+          run Shellwords::shelljoin(["test", "-e", wp_stage]) +
+            " || " + Shellwords::shelljoin(["svn", "co", "-q", "http://core.svn.wordpress.org/" + wp, wp_stage])
+          # update branches or trunk (no need to update tags)
+          run Shellwords::shelljoin(["svn", "up", "--force", "-q", wp_stage]) unless wp.start_with?("tags/")
+          # ensure a clean copy
+          run Shellwords::shelljoin(["svn", "revert", "-R", "-q", wp_stage])
+          # trailingslashit for rsync
+          wp_stage << '/' unless wp_stage[-1..-1] == '/'
+          # push wordpress into the right place (release_path by default, could be #{release_path}/wp)
+          run Shellwords::shelljoin(["rsync", "--exclude=.svn", "--ignore-existing", "-a", wp_stage, wp_target])
+        end
+
+        desc <<-DESC
+              [internal] Installs WordPress with a local svn cache/copy, compressing and uploading a snapshot
+        DESC
+        task :with_copy, :except => { :no_release => true } do
+          wp = fetch(:wordpress_version, "trunk")
+          wp_target = fetch(:wp_path, release_path)
+          Dir.mktmpdir do |tmp_dir|
+            tmpdir = fetch(:cf_database_store, tmp_dir)
+            wp = fetch(:wordpress_version, "trunk")
+            Dir.chdir(tmpdir) do 
+              if !(wp.start_with?("tags/") || wp.start_with?("branches/") || wp == "trunk")
+                wp = "branches/#{wp}"
+              end
+              wp_stage = File.join(tmpdir, "wordpress", wp)
+              ["branches", "tags"].each do |wpsvntype|
+                system Shellwords::shelljoin(["mkdir", "-p", File.join(tmpdir, "wordpress", wpsvntype)])
+              end
+
+              puts "Getting WordPress #{wp} to #{wp_stage}"
+              system Shellwords::shelljoin(["test", "-e", wp_stage]) +
+                " || " + Shellwords::shelljoin(["svn", "co", "-q", "http://core.svn.wordpress.org/" + wp, wp_stage])
+              system Shellwords::shelljoin(["svn", "up", "--force", "-q", wp_stage]) unless wp.start_with?("tags/")
+              system Shellwords::shelljoin(["svn", "revert", "-R", "-q", wp_stage])
+              wp_stage << '/' unless wp_stage[-1..-1] == '/'
+              Dir.mktmpdir do |copy_dir|
+                comp = Struct.new(:extension, :compress_command, :decompress_command)
+                remote_tar = fetch(:copy_remote_tar, 'tar')
+                local_tar = fetch(:copy_local_tar, 'tar')
+                type = fetch(:copy_compression, :gzip)
+                compress = case type
+                           when :gzip, :gz   then comp.new("tar.gz",  [local_tar, '-c -z --exclude .svn -f'], [remote_tar, '-x -k -z -f'])
+                           when :bzip2, :bz2 then comp.new("tar.bz2", [local_tar, '-c -j --exclude .svn -f'], [remote_tar, '-x -k -j -f'])
+                           when :zip         then comp.new("zip",     %w(zip -qyr), %w(unzip -q))
+                           else raise ArgumentError, "invalid compression type #{type.inspect}"
+                           end
+                compressed_filename = "wp-" + File.basename(fetch(:release_path)) + "." + compress.extension
+                local_file = File.join(copy_dir, compressed_filename)
+                puts "Compressing #{wp_stage} to #{local_file}"
+                Dir.chdir(wp_stage) do
+                  system([compress.compress_command, local_file, '.'].join(' '))
+                end
+                remote_file = File.join(fetch(:copy_remote_dir, '/tmp'), File.basename(local_file))
+                puts "Pushing #{local_file} to #{remote_file} to deploy"
+                upload(local_file, remote_file)
+                wp_target = fetch(:wp_path, fetch(:release_path))
+                run("mkdir -p #{wp_target} && cd #{wp_target} && (#{compress.decompress_command.join(' ')} #{remote_file} || echo 'tar errors for normal conditions') && rm #{remote_file}")
+              end
+
+            end
+          end
+        end
+
+        desc <<-DESC
+              [internal] Installs WordPress to the application deploy point
+        DESC
+        task :default, :except => { :no_release => true } do
+          if fetch(:strategy).class <= Capistrano::Deploy::Strategy.new(:remote).class
+            with_remote_cache
+          else
+            with_copy
+          end
+        end
+      end
+
+      desc <<-DESC
+              [internal] (currently unused) Generate config files if appropriate
+      DESC
+      task :generate_config, :except => { :no_release => true } do
+        # live config lives in wp-config.php; dev config loaded with local-config.php
+        # this method does nothing for now
+      end
+
+      desc <<-DESC
+              [internal] Symlinks specified files (usually uploads/blogs.dir/cache directories)
+      DESC
+      task :link_symlinks, :except => { :no_release => true } do
+        symlinks = _combine_filehash(fetch(:base_wp_symlinks), fetch(:wp_symlinks))
+        symlinks.each do |src, targ|
+          next if targ.nil? || targ == false || targ.empty?
+          src = File.join(shared_path, src) unless src.include?(shared_path)
+          targ = File.join(release_path, targ) unless targ.include?(release_path)
+          run [
+            Shellwords::shelljoin(["test", "-e", src]),
+            Shellwords::shelljoin(["test", "-d", targ]),
+            Shellwords::shelljoin(["rm", "-rf", targ])
+          ].join(' && ') + " || true"
+          run Shellwords::shelljoin(["test", "-e", src]) + " && " + Shellwords::shelljoin(["ln", "-nsf", src, targ]) + " || true"
+        end
+      end
+
+      desc <<-DESC
+              [internal] Copies specified files (usually advanced-cache, object-cache, db-config)
+      DESC
+      task :copy_configs, :except => { :no_release => true } do
+        configs = _combine_filehash(fetch(:base_wp_configs), fetch(:wp_configs))
+        configs.each do |src, targ|
+          next if targ.nil? || targ == false || targ.empty?
+          src = File.join(shared_path, src) unless src.include?(shared_path)
+          targ = File.join(release_path, targ) unless targ.include?(release_path)
+          run "ls -d #{src} >/dev/null 2>&1 && cp -urp #{src} #{targ} || true"
+          #run Shellwords::shelljoin(["test", "-e", src]) + " && " + Shellwords::shelljoin(["cp", "-rp", src, targ]) + " || true"
+        end
+      end
+
+      desc <<-DESC
+              [internal] Pushes up local-config.php, .htaccess, others if they exist for that stage
+      DESC
+      task :do_stage_specific_overrides, :except => { :no_release => true } do
+        next unless fetch(:stage, false)
+        overrides = _combine_filehash(fetch(:base_stage_specific_overrides), fetch(:stage_specific_overrides))
+        overrides.each do |src, targ|
+          next if targ.nil? || targ == false || targ.empty?
+          src = File.join("config", "#{stage}-#{src}")
+          targ = File.join(release_path, targ) unless targ.include?(release_path)
+          if File.exist?(src)
+            upload(src, targ)
+          end
+        end
+      end
+
+      desc <<-DESC
+              [internal] Ensure the release path has an updated modified time for deploy:cleanup
+      DESC
+      task :touch_release, :except => { :no_release => true } do
+        run "touch '#{release_path}'"
+      end
+    end
+
+    #===========================================================================
+    # util / debugging code
+
+    namespace :debugging do
+
+      namespace :release_info do
+        desc <<-DESC
+            [internal] Debugging info about releases.
+        DESC
+
+        task :default do
+          %w{releases_path shared_path current_path release_path releases previous_release current_revision latest_revision previous_revision latest_release}.each do |var|
+            puts "#{var}: #{eval(var)}"
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/crowdfavorite/tasks.rb

@@ -0,0 +1,4 @@
+require 'crowdfavorite'
+module CrowdFavorite::Tasks
+end
+

data/lib/crowdfavorite/version.rb

@@ -0,0 +1,3 @@
+module CrowdFavorite
+  VERSION = '0.2.0'
+end

data/lib/crowdfavorite/wordpress.rb

@@ -0,0 +1,13 @@
+# Default set of tasks for wordpress deploys, including all the before/after bindings
+
+require 'crowdfavorite/tasks/wordpress'
+require 'crowdfavorite/tasks/localchanges'
+
+module CrowdFavorite::WordPress
+  extend CrowdFavorite::Support::Namespace
+  namespace :cf do
+    after "deploy:finalize_update", "cf:localchanges:snapshot_deploy"
+    before "deploy", "cf:localchanges:compare"
+  end
+end
+

data/lib/crowdfavorite.rb

@@ -0,0 +1,9 @@
+require 'rubygems'
+
+module CrowdFavorite
+  module Support
+    autoload :Namespace, 'crowdfavorite/support/namespace'
+  end
+  autoload :Version, 'crowdfavorite/version'
+end
+

data/spec/.rspec

@@ -0,0 +1 @@
+--color