capistrano-pyenv 1.0.0rc1 → 1.0.0rc2

data/lib/capistrano-pyenv/version.rb

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

data/lib/capistrano-pyenv.rb

@@ -17,8 +17,22 @@ module Capistrano
           _cset(:pyenv_bin) {
             File.join(pyenv_bin_path, "pyenv")
           }
-          _cset(:pyenv_cmd) {
-            "env PYENV_VERSION=#{pyenv_python_version.dump} #{pyenv_bin}"
+          def pyenv_command(options={})
+            environment = pyenv_environment.merge(options.fetch(:env, {}))
+            environment["PYENV_VERSION"] = options[:version] if options.key?(:version)
+            if environment.empty?
+              pyenv_bin
+            else
+              env = (["env"] + environment.map { |k, v| "#{k}=#{v.dump}" }).join(" ")
+              "#{env} #{pyenv_bin}"
+            end
+          end
+          _cset(:pyenv_cmd) { pyenv_command(:version => pyenv_python_version) } # this declares PYENV_VERSION.
+          _cset(:pyenv_environment) {
+            {
+              "PYENV_ROOT" => pyenv_path,
+              "PATH" => [ pyenv_shims_path, pyenv_bin_path, "$PATH" ].join(":"),
+            }
           }
           _cset(:pyenv_repository, 'git://github.com/yyuu/pyenv.git')
           _cset(:pyenv_branch, 'master')
@@ -52,12 +66,24 @@ module Capistrano
 
           desc("Setup pyenv.")
           task(:setup, :except => { :no_release => true }) {
+            #
+            # skip installation if the requested version has been installed.
+            #
+            begin
+              installed = pyenv_python_versions.include?(pyenv_python_version)
+            rescue
+              installed = false
+            end
+            _setup unless installed
+            configure if pyenv_setup_shell
+          }
+          after "deploy:setup", "pyenv:setup"
+
+          task(:_setup, :except => { :no_release => true }) {
             dependencies if pyenv_install_dependencies
             update
-            configure if pyenv_setup_shell
             build
           }
-          after 'deploy:setup', 'pyenv:setup'
 
           def _update_repository(destination, options={})
             configuration = Capistrano::Configuration.new()
@@ -97,10 +123,7 @@ module Capistrano
           }
 
           def _setup_default_environment
-            env = fetch(:default_environment, {}).dup
-            env["PYENV_ROOT"] = pyenv_path
-            env["PATH"] = [ pyenv_shims_path, pyenv_bin_path, env.fetch("PATH", "$PATH") ].join(":")
-            set(:default_environment, env)
+            set(:default_environment, default_environment.merge(pyenv_environment))
           end
 
           _cset(:pyenv_setup_default_environment) {
@@ -111,7 +134,7 @@ module Capistrano
               true
             end
           }
-          # workaround for `multistage` of capistrano-ext.
+          # workaround for loading `capistrano-rbenv` later than `capistrano/ext/multistage`.
           # https://github.com/yyuu/capistrano-rbenv/pull/5
           if top.namespaces.key?(:multistage)
             after "multistage:ensure" do
@@ -119,7 +142,15 @@ module Capistrano
             end
           else
             on :start do
-              _setup_default_environment if pyenv_setup_default_environment
+              if top.namespaces.key?(:multistage)
+                # workaround for loading `capistrano-rbenv` earlier than `capistrano/ext/multistage`.
+                # https://github.com/yyuu/capistrano-rbenv/issues/7
+                after "multistage:ensure" do
+                  _setup_default_environment if pyenv_setup_default_environment
+                end
+              else
+                _setup_default_environment if pyenv_setup_default_environment
+              end
             end
           end
 
@@ -270,52 +301,51 @@ module Capistrano
               end
             end
             pyenv.exec("#{python} --version") # chck if python is executable
-            pyenv.global(pyenv_python_version)
+            pyenv.global(pyenv_python_version) if fetch(:pyenv_setup_global_version, true)
           }
 
           # call `pyenv rehash` to update shims.
           def rehash(options={})
-            run("#{pyenv_cmd} rehash", options)
+            invoke_command("#{pyenv_command} rehash", options)
           end
 
           def global(version, options={})
-            run("#{pyenv_cmd} global #{version.dump}", options)
+            invoke_command("#{pyenv_command} global #{version.dump}", options)
           end
 
           def local(version, options={})
             path = options.delete(:path)
-            if path
-              run("cd #{path.dump} && #{pyenv_cmd} local #{version.dump}", options)
-            else
-              run("#{pyenv_cmd} local #{version.dump}", options)
-            end
+            execute = []
+            execute << "cd #{path.dump}" if path
+            execute << "#{pyenv_command} local #{version.dump}"
+            invoke_command(execute.join(" && "), options)
           end
 
           def which(command, options={})
             path = options.delete(:path)
-            if path
-              capture("cd #{path.dump} && #{pyenv_cmd} which #{command.dump}", options).strip
-            else
-              capture("#{pyenv_cmd} which #{command.dump}", options).strip
-            end
+            version = ( options.delete(:version) || pyenv_python_version )
+            execute = []
+            execute << "cd #{path.dump}" if path
+            execute << "#{pyenv_command(:version => version)} which #{command.dump}"
+            capture(execute.join(" && "), options).strip
           end
 
           def exec(command, options={})
             # users of pyenv.exec must sanitize their command line.
             path = options.delete(:path)
-            if path
-              run("cd #{path.dump} && #{pyenv_cmd} exec #{command}", options)
-            else
-              run("#{pyenv_cmd} exec #{command}", options)
-            end
+            version = ( options.delete(:version) || pyenv_python_version )
+            execute = []
+            execute << "cd #{path.dump}" if path
+            execute << "#{pyenv_command(:version => version)} exec #{command}"
+            invoke_command(execute.join(" && "), options)
           end
 
           def versions(options={})
-            capture("#{pyenv_cmd} versions --bare", options).split(/(?:\r?\n)+/)
+            capture("#{pyenv_command} versions --bare", options).split(/(?:\r?\n)+/)
           end
 
           def available_versions(options={})
-            capture("#{pyenv_cmd} install --complete", options).split(/(?:\r?\n)+/)
+            capture("#{pyenv_command} install --complete", options).split(/(?:\r?\n)+/)
           end
 
           _cset(:pyenv_install_python_threads) {
@@ -323,15 +353,16 @@ module Capistrano
           }
           # create build processes as many as processor count
           _cset(:pyenv_make_options) { "-j #{pyenv_install_python_threads}" }
+          _cset(:pyenv_configure_options, nil)
           def install(version, options={})
-            execute = []
-            execute << "export MAKE_OPTS=#{pyenv_make_options.dump}" if pyenv_make_options
-            execute << "#{pyenv_cmd} install #{version.dump}"
-            run(execute.join(" && "), options)
+            environment = {}
+            environment["CONFIGURE_OPTS"] = pyenv_configure_options.to_s if pyenv_configure_options
+            environment["MAKE_OPTS"] = pyenv_make_options.to_s if pyenv_make_options
+            invoke_command("#{pyenv_command(:env => environment)} install #{version.dump}", options)
           end
 
           def uninstall(version, options={})
-            run("#{pyenv_cmd} uninstall -f #{version.dump}", options)
+            invoke_command("#{pyenv_command} uninstall -f #{version.dump}", options)
           end
 
           def virtualenv(version, venv, options={})

data/test/config/deploy.rb

@@ -20,40 +20,136 @@ role :db,  "192.168.33.10", :primary => true
 $LOAD_PATH.push(File.expand_path("../../lib", File.dirname(__FILE__)))
 require "capistrano-pyenv"
 
-namespace(:test_all) {
+task(:test_all) {
+  find_and_execute_task("test_default")
+  find_and_execute_task("test_with_virtualenv")
+  find_and_execute_task("test_without_global")
+}
+
+namespace(:test_default) {
   task(:default) {
-    find_and_execute_task("pyenv:setup")
     methods.grep(/^test_/).each do |m|
       send(m)
     end
-    find_and_execute_task("pyenv:purge")
+  }
+  before "test_default", "test_default:setup"
+  after "test_default", "test_default:teardown"
+
+  task(:setup) {
+    find_and_execute_task("pyenv:setup")
   }
 
-  task(:test_pyenv_is_installed) {
+  task(:teardown) {
+  }
+
+  task(:test_pyenv) {
     run("pyenv --version")
   }
 
-  task(:test_python_is_installed) {
+## standard
+  task(:test_pyenv_exec) {
+    pyenv.exec("python --version")
+  }
+
+  task(:test_run_pyenv_exec) {
     run("pyenv exec python --version")
   }
 
-  task(:test_pip_is_installed) {
+## with path
+  task(:test_pyenv_exec_with_path) {
+    pyenv.exec("python -c 'import os;assert os.getcwd()==\"/\"'", :path => "/")
+  }
+
+# task(:test_pyenv_exec_python_via_sudo_with_path) {
+#   # capistrano does not provide safer way to invoke multiple commands via sudo.
+#   pyenv.exec("python -c 'import os;assert os.getcwd()==\"/\" and os.getuid()==0'", :path => "/", :via => :sudo )
+# }
+
+## via sudo
+  task(:test_pyenv_exec_via_sudo) {
+    pyenv.exec("python -c 'import os;assert os.getuid()==0'", :via => :sudo)
+  }
+
+  task(:test_run_sudo_pyenv_exec) {
+    # we may not be able to invoke pyenv since sudo may reset $PATH.
+    # if you prefer to invoke pyenv via sudo, call it with absolute path.
+#   run("#{sudo} pyenv exec python -c 'import os;assert os.getuid()==0'")
+    run("#{sudo} #{pyenv_cmd} exec python -c 'import os;assert os.getuid()==0'")
+  }
+
+  task(:test_sudo_pyenv_exec) {
+    sudo("#{pyenv_cmd} exec python -c 'import os;assert os.getuid()==0'")
+  }
+
+## pip
+  task(:test_pyenv_exec_pip) {
     run("pyenv exec pip --version")
   }
+}
+
+namespace(:test_with_virtualenv) {
+  task(:default) {
+    methods.grep(/^test_/).each do |m|
+      send(m)
+    end
+  }
+  before "test_with_virtualenv", "test_with_virtualenv:setup"
+  after "test_with_virtualenv", "test_with_virtualenv:teardown"
 
-  task(:test_virtualenv) {
-    python_version = pyenv_python_version
+  task(:setup) {
     set(:pyenv_use_virtualenv, true)
+    set(:pyenv_virtualenv_python_version, pyenv_python_version)
     set(:pyenv_python_version, "venv")
-    set(:pyenv_virtualenv_python_version, python_version)
-
     find_and_execute_task("pyenv:setup")
-    run("pyenv exec python --version")
+   }
 
+  task(:teardown) {
     set(:pyenv_use_virtualenv, false)
-    set(:pyenv_python_version, python_version)
+    set(:pyenv_python_version, pyenv_virtualenv_python_version)
     set(:pyenv_virtualenv_python_version, nil)
   }
+
+  task(:test_pyenv_exec) {
+    pyenv.exec("python --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(pyenv_path, "version")
+    run("mv -f #{version_file} #{version_file}.orig")
+    set(:pyenv_setup_global_version, false)
+    find_and_execute_task("pyenv:setup")
+    run("test \! -f #{version_file.dump}")
+  }
+
+  task(:teardown) {
+    version_file = File.join(pyenv_path, "version")
+    run("mv -f #{version_file}.orig #{version_file}")
+  }
+
+## standard
+  task(:test_pyenv_exec_python) {
+    pyenv.exec("python --version")
+  }
+
+## with path
+  task(:test_pyenv_exec_python_with_path) {
+    pyenv.exec("python -c 'import os;assert os.getcwd()==\"/\"'", :path => "/")
+  }
+
+## via sudo
+  task(:test_pyenv_exec_python_via_sudo) {
+    pyenv.exec("python -c 'import os;assert os.getuid()==0'", :via => :sudo)
+  }
 }
 
 # vim:set ft=ruby sw=2 ts=2 :

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: capistrano-pyenv
 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