capistrano-rbenv 1.0.0rc1 → 1.0.0rc2

data/lib/capistrano-rbenv.rb

@@ -17,8 +17,22 @@ module Capistrano
           _cset(:rbenv_bin) {
             File.join(rbenv_bin_path, "rbenv")
           }
-          _cset(:rbenv_cmd) {
-            "env RBENV_VERSION=#{rbenv_ruby_version.dump} #{rbenv_bin}"
+          def rbenv_command(options={})
+            environment = rbenv_environment.merge(options.fetch(:env, {}))
+            environment["RBENV_VERSION"] = options[:version] if options.key?(:version)
+            if environment.empty?
+              rbenv_bin
+            else
+              env = (["env"] + environment.map { |k, v| "#{k}=#{v.dump}" }).join(" ")
+              "#{env} #{rbenv_bin}"
+            end
+          end
+          _cset(:rbenv_cmd) { rbenv_command(:version => rbenv_ruby_version) } # this declares RBENV_VERSION.
+          _cset(:rbenv_environment) {
+            {
+              "RBENV_ROOT" => rbenv_path,
+              "PATH" => [ rbenv_shims_path, rbenv_bin_path, "$PATH" ].join(":"),
+            }
           }
           _cset(:rbenv_repository, 'git://github.com/sstephenson/rbenv.git')
           _cset(:rbenv_branch, 'master')
@@ -60,13 +74,25 @@ module Capistrano
 
           desc("Setup rbenv.")
           task(:setup, :except => { :no_release => true }) {
+            #
+            # skip installation if the requested version has been installed.
+            #
+            begin
+              installed = rbenv_ruby_versions.include?(rbenv_ruby_version)
+            rescue
+              installed = false
+            end
+            _setup unless installed
+            configure if rbenv_setup_shell
+            setup_bundler if rbenv_install_bundler
+          }
+          after "deploy:setup", "rbenv:setup"
+
+          task(:_setup, :except => { :no_release => true }) {
             dependencies if rbenv_install_dependencies
             update
-            configure if rbenv_setup_shell
             build
-            setup_bundler if rbenv_install_bundler
           }
-          after 'deploy:setup', 'rbenv:setup'
 
           def _update_repository(destination, options={})
             configuration = Capistrano::Configuration.new()
@@ -106,10 +132,7 @@ module Capistrano
           }
 
           def _setup_default_environment
-            env = fetch(:default_environment, {}).dup
-            env["RBENV_ROOT"] = rbenv_path
-            env["PATH"] = [ rbenv_shims_path, rbenv_bin_path, env.fetch("PATH", "$PATH") ].join(":")
-            set(:default_environment, env)
+            set(:default_environment, default_environment.merge(rbenv_environment))
           end
 
           _cset(:rbenv_setup_default_environment) {
@@ -278,69 +301,66 @@ module Capistrano
               rbenv.install(rbenv_ruby_version)
             end
             rbenv.exec("#{ruby} --version") # check if ruby is executable
-            rbenv.global(rbenv_ruby_version)
+            rbenv.global(rbenv_ruby_version) if fetch(:rbenv_setup_global_version, true)
           }
 
           _cset(:rbenv_bundler_gem, 'bundler')
           task(:setup_bundler, :except => { :no_release => true }) {
             gem = "#{rbenv_cmd} exec gem"
-            if v = fetch(:rbenv_bundler_version, nil)
-              q = "-n #{rbenv_bundler_gem} -v #{v}"
-              f = "fgrep #{rbenv_bundler_gem} | fgrep #{v}"
-              i = "-v #{v} #{rbenv_bundler_gem}"
+            if version = fetch(:rbenv_bundler_version, nil)
+              query_args = "-i -n #{rbenv_bundler_gem.dump} -v #{version.dump}"
+              install_args = "-v #{version.dump} #{rbenv_bundler_gem.dump}"
             else
-              q = "-n #{rbenv_bundler_gem}"
-              f = "fgrep #{rbenv_bundler_gem}"
-              i = "#{rbenv_bundler_gem}"
+              query_args = "-i -n #{rbenv_bundler_gem.dump}"
+              install_args = "#{rbenv_bundler_gem.dump}"
             end
-            run("unset -v GEM_HOME; #{gem} query #{q} 2>/dev/null | #{f} || #{gem} install -q #{i}")
+            run("unset -v GEM_HOME; #{gem} query #{query_args} 2>/dev/null || #{gem} install -q #{install_args}")
             rbenv.rehash
             run("#{bundle_cmd} version")
           }
 
           # call `rbenv rehash` to update shims.
           def rehash(options={})
-            run("#{rbenv_cmd} rehash", options)
+            invoke_command("#{rbenv_command} rehash", options)
           end
 
           def global(version, options={})
-            run("#{rbenv_cmd} global #{version.dump}", options)
+            invoke_command("#{rbenv_command} global #{version.dump}", options)
           end
 
           def local(version, options={})
             path = options.delete(:path)
-            if path
-              run("cd #{path.dump} && #{rbenv_cmd} local #{version.dump}", options)
-            else
-              run("#{rbenv_cmd} local #{version.dump}", options)
-            end
+            execute = []
+            execute << "cd #{path.dump}" if path
+            execute << "#{rbenv_command} local #{version.dump}"
+            invoke_command(execute.join(" && "), options)
           end
 
           def which(command, options={})
             path = options.delete(:path)
-            if path
-              capture("cd #{path.dump} && #{rbenv_cmd} which #{command.dump}", options).strip
-            else
-              capture("#{rbenv_cmd} which #{command.dump}", options).strip
-            end
+            version = ( options.delete(:version) || rbenv_ruby_version )
+            execute = []
+            execute << "cd #{path.dump}" if path
+            execute << "#{rbenv_command(:version => version)} which #{command.dump}"
+            capture(execute.join(" && "), options).strip
           end
 
           def exec(command, options={})
             # users of rbenv.exec must sanitize their command line.
             path = options.delete(:path)
-            if path
-              run("cd #{path.dump} && #{rbenv_cmd} exec #{command}", options)
-            else
-              run("#{rbenv_cmd} exec #{command}", options)
-            end
+            version = ( options.delete(:version) || rbenv_ruby_version )
+            execute = []
+            execute << "cd #{path.dump}" if path
+            execute << "#{rbenv_command(:version => version)} exec #{command}"
+            invoke_command(execute.join(" && "), options)
           end
 
           def versions(options={})
-            capture("#{rbenv_cmd} versions --bare", options).split(/(?:\r?\n)+/)
+            capture("#{rbenv_command} versions --bare", options).split(/(?:\r?\n)+/)
           end
 
           def available_versions(options={})
-            capture("#{rbenv_cmd} install --complete", options).split(/(?:\r?\n)+/)
+            capture("#{rbenv_command} install --complete", options).split(/(?:\r?\n)+/)
           end
 
           _cset(:rbenv_install_ruby_threads) {
@@ -348,15 +368,16 @@ module Capistrano
           }
           # create build processes as many as processor count
           _cset(:rbenv_make_options) { "-j #{rbenv_install_ruby_threads}" }
+          _cset(:rbenv_configure_options, nil)
           def install(version, options={})
-            execute = []
-            execute << "export MAKE_OPTS=#{rbenv_make_options.dump}" if rbenv_make_options
-            execute << "#{rbenv_cmd} install #{version.dump}"
-            run(execute.join(" && "), options)
+            environment = {}
+            environment["CONFIGURE_OPTS"] = rbenv_configure_options.to_s if rbenv_configure_options
+            environment["MAKE_OPTS"] = rbenv_make_options.to_s if rbenv_make_options
+            invoke_command("#{rbenv_command(:env => environment)} install #{version.dump}", options)
           end
 
           def uninstall(version, options={})
-            run("#{rbenv_cmd} uninstall -f #{version.dump}", options)
+            invoke_command("#{rbenv_command} uninstall -f #{version.dump}", options)
           end
         }
       }

data/lib/capistrano-rbenv/version.rb

@@ -1,5 +1,5 @@
 module Capistrano
   module RbEnv
-    VERSION = "1.0.0rc1"
+    VERSION = "1.0.0rc2"
   end
 end

data/test/config/deploy.rb

@@ -20,25 +20,115 @@ role :db,  "192.168.33.10", :primary => true
 $LOAD_PATH.push(File.expand_path("../../lib", File.dirname(__FILE__)))
 require "capistrano-rbenv"
 
-namespace(:test_all) {
+task(:test_all) {
+  find_and_execute_task("test_default")
+  find_and_execute_task("test_without_global")
+}
+
+namespace(:test_default) {
   task(:default) {
-    find_and_execute_task("rbenv:setup")
     methods.grep(/^test_/).each do |m|
       send(m)
     end
-    find_and_execute_task("rbenv:purge")
+  }
+  before "test_default", "test_default:setup"
+  after "test_default", "test_default:teardown"
+
+  task(:setup) {
+    find_and_execute_task("rbenv:setup")
   }
 
-  task(:test_rbenv_is_installed) {
+  task(:teardown) {
+  }
+
+  task(:test_rbenv) {
     run("rbenv --version")
   }
 
-  task(:test_ruby_is_installed) {
+## standard
+  task(:test_rbenv_exec) {
+    rbenv.exec("ruby --version")
+  }
+
+  task(:test_run_rbenv_exec) {
     run("rbenv exec ruby --version")
   }
 
-  task(:test_bundler_is_installed) {
-    run("rbenv exec bundle version")
+## with path
+  task(:test_rbenv_exec_with_path) {
+    rbenv.exec("ruby -e 'exit(Dir.pwd==%{/}?0:1)'", :path => "/")
+  }
+
+# task(:test_rbenv_exec_ruby_via_sudo_with_path) {
+#   # capistrano does not provide safer way to invoke multiple commands via sudo.
+#   rbenv.exec("ruby -e 'exit(Dir.pwd==%{/}&&Process.uid==0?0:1'", :path => "/", :via => :sudo )
+# }
+
+## via sudo
+  task(:test_rbenv_exec_via_sudo) {
+    rbenv.exec("ruby -e 'exit(Process.uid==0?0:1)'", :via => :sudo)
+  }
+
+  task(:test_run_sudo_rbenv_exec) {
+    # we may not be able to invoke rbenv since sudo may reset $PATH.
+    # if you prefer to invoke rbenv via sudo, call it with absolute path.
+#   run("#{sudo} rbenv exec ruby -e 'exit(Process.uid==0?0:1)'")
+    run("#{sudo} #{rbenv_cmd} exec ruby -e 'exit(Process.uid==0?0:1)'")
+  }
+
+  task(:test_sudo_rbenv_exec) {
+    sudo("#{rbenv_cmd} exec ruby -e 'exit(Process.uid==0?0:1)'")
+  }
+
+## bundler
+  task(:test_run_bundle) {
+    run("#{bundle_cmd} version")
+  }
+
+  task(:test_run_sudo_bundle) {
+    run("#{sudo} #{bundle_cmd} version")
+  }
+
+  task(:test_sudo_bundle) {
+    sudo("#{bundle_cmd} version")
+  }
+}
+
+namespace(:test_without_global) {
+  task(:default) {
+    methods.grep(/^test_/).each do |m|
+      send(m)
+    end
+  }
+  before "test_without_global", "test_without_global:setup"
+  after "test_without_global", "test_without_global:teardown"
+
+  task(:setup) {
+    version_file = File.join(rbenv_path, "version")
+    run("mv -f #{version_file} #{version_file}.orig")
+    set(:rbenv_setup_global_version, false)
+    find_and_execute_task("rbenv:setup")
+    run("test \! -f #{version_file.dump}")
+  }
+
+  task(:teardown) {
+    version_file = File.join(rbenv_path, "version")
+    run("mv -f #{version_file}.orig #{version_file}")
+  }
+
+## standard
+  task(:test_rbenv_exec_ruby) {
+    rbenv.exec("ruby --version")
+  }
+
+## with path
+  task(:test_rbenv_exec_ruby_with_path) {
+    rbenv.exec("ruby -e 'exit(Dir.pwd==%{/}?0:1)'", :path => "/")
+  }
+
+## via sudo
+  task(:test_rbenv_exec_ruby_via_sudo) {
+    rbenv.exec("ruby -e 'exit(Process.uid==0?0:1)'", :via => :sudo)
   }
 }
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: capistrano-rbenv
 version: !ruby/object:Gem::Version
-  version: 1.0.0rc1
+  version: 1.0.0rc2
   prerelease: 5
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-03-11 00:00:00.000000000 Z
+date: 2013-03-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: capistrano