lib/capistrano-sbt/deploy.rb in capistrano-sbt-0.0.5 vs lib/capistrano-sbt/deploy.rb in capistrano-sbt-0.0.6

@@ -1,16 +1,15 @@
 
 require 'capistrano'
-require 'tempfile'
 require 'uri'
 
 module Capistrano
   module Sbt
     def self.extended(configuration)
       configuration.load {
         namespace(:sbt) {
-          _cset(:sbt_version, '0.11.2')
+          _cset(:sbt_version, '0.12.2')
           _cset(:sbt_group_id) {
             case sbt_version
             when /^0\.(?:7|10)\.\d+$/, /^0\.11\.[0-2]$/
               'org.scala-tools.sbt'
             else
@@ -182,11 +181,11 @@
             execute.join(' && ')
           end
 
           task(:update_settings, :roles => :app, :except => { :no_release => true }) {
             srcs = sbt_settings.map { |f| File.join(sbt_template_path, f) }
-            tmps = sbt_settings.map { |f| t=Tempfile.new('sbt');s=t.path;t.close(true);s }
+            tmps = sbt_settings.map { |f| capture("mktemp").chomp }
             dsts = sbt_settings.map { |f| File.join(sbt_settings_path, f) }
             begin
               srcs.zip(tmps).each do |src, tmp|
                 put(template(src), tmp)
               end
@@ -196,11 +195,11 @@
             end
           }
 
           task(:update_settings_locally, :except => { :no_release => true }) {
             srcs = sbt_settings_local.map { |f| File.join(sbt_template_path, f) }
-            tmps = sbt_settings.map { |f| t=Tempfile.new('sbt');s=t.path;t.close(true);s }
+            tmps = sbt_settings.map { |f| `mktemp`.chomp }
             dsts = sbt_settings_local.map { |f| File.join(sbt_settings_path_local, f) }
             begin
               srcs.zip(tmps).each do |src, tmp|
                 File.open(tmp, 'wb') { |fp| fp.write(template(src)) }
               end
@@ -228,25 +227,55 @@
               execute_locally
               upload_locally
             }
           }
 
+          def _sbt(cmd, path, goals=[])
+            "cd #{path.dump} && #{cmd} #{goals.map { |s| s.dump }.join(' ')}"
+          end
+
+          def _sbt_parse_version(s)
+            # FIXME: is there any better way to get project version?
+            lastline = s.split(/(?:\r?\n)+/)[-1]
+            lastline.split[-1]
+          end
+
+          _cset(:sbt_release_build, false)
+          _cset(:sbt_snapshot_pattern, /-SNAPSHOT$/i)
+          _cset(:sbt_project_version) {
+            _sbt_parse_version(capture(_sbt(sbt_cmd, sbt_project_path, ["show version"])))
+          }
+          _cset(:sbt_project_version_local) {
+            _sbt_parse_version(run_locally(_sbt(sbt_cmd_local, sbt_project_path_local, ["show version"])))
+          }
+
+          def _validate_project_version(version_key)
+            if sbt_release_build
+              version = fetch(version_key)
+              if sbt_snapshot_pattern === version
+                abort("Skip to build project since \`#{version}' is a SNAPSHOT version.")
+              end
+            end
+          end
+
           desc("Perform sbt build.")
           task(:execute, :roles => :app, :except => { :no_release => true }) {
             on_rollback {
-              run("cd #{sbt_project_path} && #{sbt_cmd} clean")
+              run(_sbt(sbt_cmd, sbt_project_path, %w(clean)))
             }
-            run("cd #{sbt_project_path} && #{sbt_cmd} #{sbt_goals.join(' ')}")
+            _validate_project_version(:sbt_project_version)
+            run(_sbt(sbt_cmd, sbt_project_path, sbt_goals))
           }
 
           desc("Perform sbt build locally.")
           task(:execute_locally, :roles => :app, :except => { :no_release => true }) {
             on_rollback {
-              run_locally("cd #{sbt_project_path_local} && #{sbt_cmd_local} clean")
+              run_locally(_sbt(sbt_cmd_local, sbt_project_path_local, %w(clean)))
             }
-            cmd = "cd #{sbt_project_path_local} && #{sbt_cmd_local} #{sbt_goals.join(' ')}"
-            logger.info(cmd)
-            abort("execution failure") unless system(cmd)
+            _validate_project_version(:sbt_project_version_local)
+            cmdline = _sbt(sbt_cmd_local, sbt_project_path_local, sbt_goals)
+            logger.info(cmdline)
+            abort("execution failure") unless system(cmdline)
           }
 
           _cset(:sbt_tar, 'tar')
           _cset(:sbt_tar_local, 'tar')
           _cset(:sbt_target_archive) {