git-deploy 0.2.0 → 0.3.0

data/LICENSE

@@ -0,0 +1,18 @@
+Copyright (c) 2009 Mislav Marohnić
+
+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/lib/git_deploy.rb

@@ -1,5 +1,4 @@
 require 'capistrano/recipes/deploy/scm/git'
-require 'capistrano/recipes/deploy/strategy/checkout'
 
 Capistrano::Configuration.instance(true).load do
   def _cset(name, *args, &block)
@@ -15,23 +14,13 @@ Capistrano::Configuration.instance(true).load do
   _cset(:multiple_hosts) { roles.values.map{ |v| v.servers}.flatten.uniq.size > 1 }
   _cset(:repository)  { `#{ source.local.scm('config', "remote.#{remote}.url") }`.chomp }
   _cset(:remote_host) { repository.split(':', 2).first }
-  _cset(:deploy_to)   { repository.split(':', 2).last } # "/u/apps/#{application}"
+  _cset(:deploy_to)   { repository.split(':', 2).last }
   _cset(:run_method)  { fetch(:use_sudo, true) ? :sudo : :run }
   _cset :group_writeable, false
 
   _cset(:current_branch) { File.read('.git/HEAD').chomp.split(' refs/heads/').last }
   _cset(:revision) { branch }
   _cset(:source)   { Capistrano::Deploy::SCM::Git.new(self) }
-  _cset(:strategy) { Capistrano::Deploy::Strategy::Checkout.new(self) }
-
-  # Helper for the `deploy:check' task
-  def depend(location, type, *args)
-    deps = fetch(:dependencies, {})
-    deps[location] ||= {}
-    deps[location][type] ||= []
-    deps[location][type] << args
-    set :dependencies, deps
-  end
 
   # If :run_method is :sudo (or :use_sudo is true), this executes the given command
   # via +sudo+. Otherwise is uses +run+. If :as is given as a key, it will be
@@ -44,10 +33,10 @@ Capistrano::Configuration.instance(true).load do
     raise ArgumentError, "too many arguments" if args.any?
 
     as = options.fetch(:as, fetch(:admin_runner, nil))
-    via = fetch(:run_method, :sudo)
+    
     if command
-      invoke_command(command, :via => via, :as => as)
-    elsif via == :sudo
+      invoke_command(command, :via => run_method, :as => as)
+    elsif :sudo == run_method
       sudo(:as => as)
     else
       ""
@@ -57,25 +46,43 @@ Capistrano::Configuration.instance(true).load do
   namespace :deploy do
     desc "Deploys your project."
     task :default do
-      push
+      unless multiple_hosts
+        push
+      else
+        code
+        command = ["cd #{deploy_to}"]
+        command << ".git/hooks/post-reset `cat .git/ORIG_HEAD` HEAD 2>&1 | tee -a log/deploy.log"
+        
+        run command.join(' && ')
+      end
     end
 
     task :push do
       system source.local.scm('push', remote, "#{revision}:#{branch}")
     end
 
+    task :code do
+      command = ["cd #{deploy_to}"]
+      command << source.scm('fetch', remote, "+refs/heads/#{branch}:refs/remotes/origin/#{branch}")
+      command << source.scm('reset', '--hard', "origin/#{branch}")
+      
+      run command.join(' && ')
+    end
+
     desc "Prepares servers for deployment."
     task :setup do
+      shared = fetch(:group_writeable)
+      
       command = ["#{try_sudo} mkdir -p #{deploy_to}"]
-      command << "#{try_sudo} chown $USER #{deploy_to}" if fetch(:run_method, :sudo) == :sudo
+      command << "#{try_sudo} chown $USER #{deploy_to}" if :sudo == run_method
       command << "cd #{deploy_to}"
-      command << "chmod g+w ."
-      command << "git init #{fetch(:group_writeable) ? '--shared' : ''}"
+      command << "chmod g+w ." if shared
+      command << "git init #{shared ? '--shared' : ''}"
       command << "sed -i'' -e 's/master/#{branch}/' .git/HEAD" unless branch == 'master'
-      command << "git config --bool receive.denyNonFastForwards false" if fetch(:group_writeable)
+      command << "git config --bool receive.denyNonFastForwards false" if shared
       command << "git config receive.denyCurrentBranch ignore"
       run command.join(' && ')
-
+      
       install_hooks
       push
     end
@@ -95,39 +102,20 @@ Capistrano::Configuration.instance(true).load do
     end
 
     desc <<-DESC
-      Test deployment dependencies.
+      Copy files to the currently deployed version. Use a comma-separated \
+      list in FILES to specify which files to upload.
 
-      You can define your own dependencies, as well, using the `depend' method:
+      Note that unversioned files on your server are likely to be \
+      overwritten by the next push. Always persist your changes by committing.
 
-        depend :remote, :gem, "tzinfo", ">=0.3.3"
-        depend :local, :command, "svn"
-        depend :remote, :directory, "/u/depot/files"
+        $ cap deploy:upload FILES=templates,controller.rb
+        $ cap deploy:upload FILES='config/apache/*.conf'
     DESC
-    task :check do
-      dependencies = strategy.check!
-
-      other = fetch(:dependencies, {})
-      other.each do |location, types|
-        types.each do |type, calls|
-          if type == :gem
-            dependencies.send(location).command(fetch(:gem_command, "gem")).or("`gem' command could not be found. Try setting :gem_command")
-          end
-
-          calls.each do |args|
-            dependencies.send(location).send(type, *args)
-          end
-        end
-      end
+    task :upload do
+      files = (ENV["FILES"] || "").split(",").map { |f| Dir[f.strip] }.flatten
+      abort "Please specify at least one file or directory to update (via the FILES environment variable)" if files.empty?
 
-      if dependencies.pass?
-        puts "You appear to have all necessary dependencies installed"
-      else
-        puts "The following dependencies failed. Please check them and try again:"
-        dependencies.reject { |d| d.pass? }.each do |d|
-          puts "--> #{d.message}"
-        end
-        abort
-      end
+      files.each { |file| top.upload(file, File.join(deploy_to, file)) }
     end
   end
 end

data/lib/hooks/post-receive.rb

@@ -1,4 +1,4 @@
-#!/usr/bin/ruby
+#!/usr/bin/env ruby
 if ENV['GIT_DIR'] == '.'
   # this means the script has been called as a hook, not manually.
   # get the proper GIT_DIR so we can descend into the working copy dir;

data/lib/hooks/post-reset.rb

@@ -1,8 +1,40 @@
-#!/usr/bin/ruby
+#!/usr/bin/env ruby
 RAILS_ENV = 'production'
 oldrev, newrev = ARGV
 $stdout.sync = true
 
+def parse_configuration(file)
+  config = {}
+  current = nil
+
+  File.open(file).each_line do |line|
+    case line
+    when /^\[(\w+)(?: "(.+)")\]/
+      key, subkey = $1, $2
+      current = (config[key] ||= {})
+      current = (current[subkey] ||= {}) if subkey
+    else
+      key, value = line.strip.split(' = ')
+      current[key] = value
+    end
+  end
+  
+  config
+end
+
+class Array
+  # scans the list of files to see if any of them are under the given path
+  def any_in_dir?(dir)
+    if Array === dir
+      exp = %r{^(?:#{dir.join('|')})/}
+      any? { |file| file =~ exp }
+    else
+      dir += '/'
+      any? { |file| file.index(dir) == 0 }
+    end
+  end
+end
+
 # get a list of files that changed
 changes = `git diff #{oldrev} #{newrev} --diff-filter=ACDMR --name-status`.split("\n")
 
@@ -20,19 +52,6 @@ deleted_files = changes_hash['D'] # deleted
 changed_files = modified_files + deleted_files # all
 puts "files changed: #{changed_files.size}"
 
-class Array
-  # scans the list of files to see if any of them are under the given path
-  def any_in_dir?(dir)
-    if Array === dir
-      exp = %r{^(?:#{dir.join('|')})/}
-      any? { |file| file =~ exp }
-    else
-      dir += '/'
-      any? { |file| file.index(dir) == 0 }
-    end
-  end
-end
-
 cached_assets_cleared = false
 
 # detect modified asset dirs
@@ -43,11 +62,8 @@ end
 
 unless asset_dirs.empty?
   # clear cached assets (unversioned/ignored files)
-  deleted_assets = `git ls-files -z --other -- #{asset_dirs.join(' ')} | xargs -0 rm -v`.split("\n")
-  unless deleted_assets.empty?
-    puts "cleared: #{deleted_assets.join(', ')}"
-    cached_assets_cleared = true
-  end
+  system %(git clean -x -f -- #{asset_dirs.join(' ')})
+  cached_assets_cleared = true
 end
 
 # run migrations when new ones added
@@ -56,14 +72,35 @@ if new_migrations = added_files.any_in_dir?('db/migrate')
 end
 
 if modified_files.include?('.gitmodules')
-  # sync submodule remote urls in case of changes
-  system %(git submodule sync)
   # initialize new submodules
   system %(git submodule init)
+  # sync submodule remote urls in case of changes
+  config = parse_configuration('.gitmodules')
+
+  if config['submodule']
+    config['submodule'].values.each do |submodule|
+      path = submodule['path']
+      subconf = "#{path}/.git/config"
+
+      if File.exists? subconf
+        old_url = `git config -f "#{subconf}" remote.origin.url`.chomp
+        new_url = submodule['url']
+        unless old_url == new_url
+          puts "changing #{path.inspect} URL:\n  #{old_url.inspect} → #{new_url.inspect}"
+          `git config -f "#{subconf}" remote.origin.url "#{new_url}"`
+        end
+      else
+        $stderr.puts "a submodule in #{path.inspect} doesn't exist"
+      end
+    end
+  end
 end
 # update existing submodules
 system %(git submodule update)
 
+# clean unversioned files from vendor (e.g. old submodules)
+system %(git clean -d -f vendor)
+
 # determine if app restart is needed
 if cached_assets_cleared or new_migrations or changed_files.any_in_dir?(%w(app config lib public vendor))
   require 'fileutils'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: git-deploy
 version: !ruby/object:Gem::Version 
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors: 
 - "Mislav Marohni\xC4\x87"
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-10-04 00:00:00 +02:00
+date: 2009-11-25 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -22,7 +22,7 @@ dependencies:
       - !ruby/object:Gem::Version 
         version: 2.5.9
     version: 
-description: git-deploy is a tool to install useful git hooks on your remote repository to enable git push-based, Heroku-like deployment on your host.
+description: A tool to install useful git hooks on your remote repository to enable push-based, Heroku-like deployment on your host.
 email: mislav.marohnic@gmail.com
 executables: []
 
@@ -31,12 +31,12 @@ extensions: []
 extra_rdoc_files: []
 
 files: 
-- Rakefile
 - lib/git_deploy.rb
 - lib/hooks/post-receive.rb
 - lib/hooks/post-reset.rb
 - README.markdown
-has_rdoc: true
+- LICENSE
+has_rdoc: false
 homepage: http://github.com/mislav/git-deploy
 licenses: []
 

data/Rakefile

@@ -1,34 +0,0 @@
-desc "generates .gemspec file"
-task :gemspec do
-  spec = Gem::Specification.new do |p|
-    p.name = 'git-deploy'
-    p.version = '0.2.0'
-
-    p.summary     = "Simple git push-based application deployment"
-    p.description = "git-deploy is a tool to install useful git hooks on your remote repository to enable git push-based, Heroku-like deployment on your host."
-
-    p.author = 'Mislav Marohnić'
-    p.email  = 'mislav.marohnic@gmail.com'
-    p.homepage = 'http://github.com/mislav/git-deploy'
-
-    p.add_dependency 'capistrano', '~> 2.5.9'
-    
-    p.files = FileList.new('Rakefile', '{bin,lib,sample,test,spec,rails}/**/*', 'README*', 'LICENSE*', 'CHANGELOG*')
-    p.files &= `git ls-files -z`.split("\0")
-                
-    p.executables = Dir['bin/*'].map { |f| File.basename(f) }
-
-    p.rubyforge_project = nil
-    p.has_rdoc = false
-  end
-  
-  spec_string = spec.to_ruby
-  
-  begin
-    Thread.new { eval("$SAFE = 3\n#{spec_string}", binding) }.join 
-  rescue
-    abort "unsafe gemspec: #{$!}"
-  else
-    File.open("#{spec.name}.gemspec", 'w') { |file| file.write spec_string }
-  end
-end