mina 1.2.4 → 1.2.5

data/spec/tasks/rvm_spec.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe 'rvm', type: :rake do
+  before do
+    load_default_config
+  end
+
+  describe 'rvm:use' do
+    let(:task_name) { 'rvm:use' }
+
+    context 'without an argument' do
+      it 'exits with an error message' do
+        expect do
+          invoke_all
+        end.to raise_error(SystemExit)
+           .and output(output_file('rvm_use_without_env')).to_stdout
+      end
+    end
+
+    context 'with an argument' do
+      it 'sets ruby version' do
+        expect do
+          invoke_all('3.0.0')
+        end.to output(output_file('rvm_use_with_env')).to_stdout
+      end
+    end
+  end
+
+  describe 'rvm:wrapper' do
+    let(:task_name) { 'rvm:wrapper' }
+
+    context 'without all arguments' do
+      it 'exits with an error message' do
+        expect do
+          invoke_all('ruby-3.0.0')
+        end.to raise_error(SystemExit)
+           .and output(output_file('rvm_wrapper_without_arguments')).to_stdout
+      end
+    end
+
+    context 'with all arguments' do
+      it 'calls rvm wrapper' do
+        expect do
+          invoke_all('3.0.0', 'myapp', 'unicorn')
+        end.to output(output_file('rvm_wrapper_with_arguments')).to_stdout
+      end
+    end
+  end
+end

data/spec/tasks/ry_spec.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe 'ry', type: :rake do
+  before do
+    load_default_config
+  end
+
+  describe 'ry' do
+    let(:task_name) { 'ry' }
+
+    let(:default_version_warning) { /Task 'ry' without argument will use default Ruby version\./ }
+
+    context 'without an argument' do
+      it 'prints a warning' do
+        expect do
+          invoke_all
+        end.to output(default_version_warning).to_stdout
+      end
+
+      it 'sets ruby version' do
+        expect do
+          invoke_all
+        end.to output(output_file('ry_without_env')).to_stdout
+      end
+    end
+
+    context 'with an argument' do
+      it "doesn't print a warning" do
+        expect do
+          invoke_all('3.0.0')
+        end.not_to output(default_version_warning).to_stdout
+      end
+    end
+
+    it 'sets ruby version' do
+      expect do
+        invoke_all('3.0.0')
+      end.to output(output_file('ry_with_env')).to_stdout
+    end
+  end
+end

data/tasks/mina/bundler.rb

@@ -1,21 +1,23 @@
+# frozen_string_literal: true
+
 require 'mina/default'
 
 set :bundle_bin, 'bundle'
 set :bundle_path, 'vendor/bundle'
 set :bundle_withouts, 'development test'
-set :bundle_options, -> { %{--without #{fetch(:bundle_withouts)} --path "#{fetch(:bundle_path)}" --deployment} }
+set :bundle_options, -> { %(--without #{fetch(:bundle_withouts)} --path "#{fetch(:bundle_path)}" --deployment) }
 set :shared_dirs, fetch(:shared_dirs, []).push(fetch(:bundle_path))
 
 namespace :bundle do
   desc 'Install gem dependencies using Bundler.'
   task :install do
-    comment %{Installing gem dependencies using Bundler}
-    command %{#{fetch(:bundle_bin)} install #{fetch(:bundle_options)}}
+    comment %(Installing gem dependencies using Bundler)
+    command %(#{fetch(:bundle_bin)} install #{fetch(:bundle_options)})
   end
 
   desc 'Cleans up unused gems in your bundler directory'
   task :clean do
-    comment %{Cleans up unsed gems}
-    command %{#{fetch(:bundle_bin)} clean #{fetch(:bundle_options)}}
+    comment %(Cleaning up unused gems)
+    command %(#{fetch(:bundle_bin)} clean)
   end
 end

data/tasks/mina/chruby.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 set :chruby_path, '/etc/profile.d/chruby.sh'
 
 task :chruby, :env do |_, args|
@@ -7,13 +9,13 @@ task :chruby, :env do |_, args|
     exit 1
   end
 
-  comment %{chruby to version: \\"#{args[:env]}\\"}
-  command %{
+  comment %(chruby to version: \\"#{args[:env]}\\")
+  command %(
     if [[ ! -s "#{fetch(:chruby_path)}" ]]; then
       echo "! chruby.sh init file not found"
       exit 1
     fi
-  }
-  command %{source #{fetch(:chruby_path)}}
-  command %{chruby "#{args[:env]}" || exit 1}
+  )
+  command %(source #{fetch(:chruby_path)})
+  command %(chruby "#{args[:env]}" || exit 1)
 end

data/tasks/mina/default.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'mina/install'
 
 set :port, 22
@@ -32,27 +34,28 @@ end
 
 task :debug_configuration_variables do
   if fetch(:debug_configuration_variables)
-    puts
-    puts '------- Printing current config variables -------'
-    configuration.variables.each do |key, value|
-      puts "#{key.inspect} => #{value.inspect}"
+    puts '========== Configuration variables =========='
+    configuration.variables.each_key do |key|
+      puts "#{key.inspect} => #{fetch(key).inspect}"
     end
+    puts '========== Configuration variables =========='
+    puts
   end
 end
 
 desc 'Adds repo host to the known hosts'
 task :ssh_keyscan_repo do
   ensure!(:repository)
-  repo_host = fetch(:repository).split(%r{@|://}).last.split(%r{:|\/}).first
+  repo_host = fetch(:repository).split(%r{@|://}).last.split(%r{:|/}).first
   repo_port = /:([0-9]+)/.match(fetch(:repository)) && /:([0-9]+)/.match(fetch(:repository))[1] || '22'
 
-  next if repo_host == ""
+  next if repo_host == ''
 
-  command %{
+  command %(
     if ! ssh-keygen -H -F #{repo_host} &>/dev/null; then
       ssh-keyscan -t rsa -p #{repo_port} -H #{repo_host} >> ~/.ssh/known_hosts
     fi
-  }
+  )
 end
 
 desc 'Adds domain to the known hosts'
@@ -60,11 +63,11 @@ task :ssh_keyscan_domain do
   ensure!(:domain)
   ensure!(:port)
   run :local do
-    command %{
+    command %(
       if ! ssh-keygen -H -F #{fetch(:domain)} &>/dev/null; then
         ssh-keyscan -p #{fetch(:port)} #{fetch(:domain)} >> ~/.ssh/known_hosts
       fi
-    }
+    )
   end
 end
 
@@ -83,7 +86,11 @@ task :run, [:command] do |_, args|
   end
 end
 
-desc 'Open an ssh session to the server and cd to deploy_to folder'
+desc 'Open an SSH connection and position to :deploy_to folder'
 task :ssh do
-  exec %{#{Mina::Backend::Remote.new(nil).ssh} 'cd #{fetch(:deploy_to)} && exec $SHELL'}
+  ensure!(:deploy_to)
+
+  set :execution_mode, :exec
+
+  command "cd #{fetch(:deploy_to)} && exec $SHELL"
 end

data/tasks/mina/deploy.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'mina/default'
 
 set :releases_path, -> { "#{fetch(:deploy_to)}/releases" }
@@ -12,30 +14,30 @@ set :execution_mode, :pretty
 namespace :deploy do
   desc 'Forces a deploy unlock.'
   task :force_unlock do
-    comment %{Unlocking}
-    command %{rm -f "#{fetch(:deploy_to)}/#{fetch(:lock_file)}"}
+    comment %(Unlocking)
+    command %(rm -f "#{fetch(:deploy_to)}/#{fetch(:lock_file)}")
   end
 
   desc 'Links paths set in :shared_dirs and :shared_files.'
   task :link_shared_paths do
-    comment %{Symlinking shared paths}
+    comment %(Symlinking shared paths)
 
     fetch(:shared_dirs, []).each do |linked_dir|
-      command %{
+      command %(
         if [ ! -d  "#{fetch(:shared_path)}/#{linked_dir}" ]; then
           echo "! ERROR: not set up."
           echo "The directory '#{fetch(:shared_path)}/#{linked_dir}' does not exist on the server"
           echo "You may need to run 'mina setup' first"
           exit 18
         fi
-      }
-      command %{mkdir -p #{File.dirname("./#{linked_dir}")}}
-      command %{rm -rf "./#{linked_dir}"}
-      command %{ln -s "#{fetch(:shared_path)}/#{linked_dir}" "./#{linked_dir}"}
+      )
+      command %(mkdir -p #{File.dirname("./#{linked_dir}")})
+      command %(rm -rf "./#{linked_dir}")
+      command %(ln -s "#{fetch(:shared_path)}/#{linked_dir}" "./#{linked_dir}")
     end
 
     fetch(:shared_files, []).each do |linked_path|
-      command %{ln -sf "#{fetch(:shared_path)}/#{linked_path}" "./#{linked_path}"}
+      command %(ln -sf "#{fetch(:shared_path)}/#{linked_path}" "./#{linked_path}")
     end
   end
 
@@ -45,26 +47,26 @@ namespace :deploy do
     ensure!(:deploy_to)
 
     comment %{Cleaning up old releases (keeping #{fetch(:keep_releases)})}
-    in_path "#{fetch(:releases_path)}" do
+    in_path fetch(:releases_path) do
       command %{count=$(ls -A1 | sort -rn | wc -l)}
       command %{remove=$((count > #{fetch(:keep_releases)} ? count - #{fetch(:keep_releases)} : 0))}
-      command %{ls -A1 | sort -rn | tail -n $remove | xargs rm -rf {}}
+      command %(ls -A1 | sort -rn | tail -n $remove | xargs rm -rf {})
     end
   end
 end
 
 desc 'Rollbacks the latest release'
 task :rollback do
-  comment %{Rolling back to previous release}
+  comment %(Rolling back to previous release)
 
-  in_path "#{fetch(:releases_path)}" do
+  in_path fetch(:releases_path) do
     # TODO: add check if there are more than 1 release
     command %{rollback_release=$(ls -1A | sort -n | tail -n 2 | head -n 1)}
-    comment %{Rollbacking to release: $rollback_release}
-    command %{ln -nfs #{fetch(:releases_path)}/$rollback_release #{fetch(:current_path)}}
+    comment %(Rollbacking to release: $rollback_release)
+    command %(ln -nfs #{fetch(:releases_path)}/$rollback_release #{fetch(:current_path)})
     command %{current_release=$(ls -1A | sort -n | tail -n 1)}
-    comment %{Deleting current release: $current_release}
-    command %{rm -rf #{fetch(:releases_path)}/$current_release}
+    comment %(Deleting current release: $current_release)
+    command %(rm -rf #{fetch(:releases_path)}/$current_release)
   end
 end
 
@@ -72,17 +74,17 @@ desc 'Sets up a site.'
 task :setup do
   ensure!(:deploy_to)
 
-  comment %{Setting up #{fetch(:deploy_to)}}
-  command %{mkdir -p "#{fetch(:deploy_to)}"}
-  command %{mkdir -p "#{fetch(:releases_path)}"}
-  command %{mkdir -p "#{fetch(:shared_path)}"}
+  comment %(Setting up #{fetch(:deploy_to)})
+  command %(mkdir -p "#{fetch(:deploy_to)}")
+  command %(mkdir -p "#{fetch(:releases_path)}")
+  command %(mkdir -p "#{fetch(:shared_path)}")
 
-  in_path "#{fetch(:shared_path)}" do
+  in_path fetch(:shared_path) do
     fetch(:shared_dirs, []).each do |linked_dir|
-      command %{mkdir -p "#{linked_dir}"}
+      command %(mkdir -p "#{linked_dir}")
     end
     fetch(:shared_files, []).each do |linked_path|
-      command %{mkdir -p "#{File.dirname(linked_path)}"}
+      command %(mkdir -p "#{File.dirname(linked_path)}")
     end
   end
 

data/tasks/mina/git.rb

@@ -1,9 +1,13 @@
+# frozen_string_literal: true
+
 require 'mina/default'
 
 set :branch, 'master'
 set :remove_git_dir, true
 set :remote, 'origin'
 set :git_not_pushed_message, -> { "Your branch #{fetch(:branch)} needs to be pushed to #{fetch(:remote)} before deploying" }
+set :git_local_branch_missing_message, -> { "Branch #{fetch(:branch)} doesn't exist" }
+set :git_remote_branch_missing_message, -> { "Branch #{fetch(:remote)}/#{fetch(:branch)} doesn't exist" }
 
 namespace :git do
   desc 'Clones the Git repository to the current path.'
@@ -11,43 +15,51 @@ namespace :git do
     ensure!(:repository)
     ensure!(:deploy_to)
     if set?(:commit)
-      comment %{Using git commit \\"#{fetch(:commit)}\\"}
-      command %{git clone "#{fetch(:repository)}" . --recursive}
-      command %{git checkout -b current_release "#{fetch(:commit)}" --force}
+      comment %(Using git commit \\"#{fetch(:commit)}\\")
+      command %(git clone "#{fetch(:repository)}" . --recursive)
+      command %(git checkout -b current_release "#{fetch(:commit)}" --force)
     else
-      command %{
+      command %(
         if [ ! -d "#{fetch(:deploy_to)}/scm/objects" ]; then
           echo "-----> Cloning the Git repository"
-          #{echo_cmd %[git clone "#{fetch(:repository)}" "#{fetch(:deploy_to)}/scm" --bare]}
+          #{echo_cmd %(git clone "#{fetch(:repository)}" "#{fetch(:deploy_to)}/scm" --bare)}
         else
           echo "-----> Fetching new git commits"
           #{echo_cmd %[(cd "#{fetch(:deploy_to)}/scm" && git fetch "#{fetch(:repository)}" "#{fetch(:branch)}:#{fetch(:branch)}" --force)]}
         fi &&
         echo "-----> Using git branch '#{fetch(:branch)}'" &&
-        #{echo_cmd %[git clone "#{fetch(:deploy_to)}/scm" . --recursive --branch "#{fetch(:branch)}"]}
-      }, quiet: true
+        #{echo_cmd %(git clone "#{fetch(:deploy_to)}/scm" . --recursive --branch "#{fetch(:branch)}")}
+      ), quiet: true
     end
-    comment %{Updating submodules}
-    command %{git submodule update}
-    comment %{Using this git commit}
-    command %{git rev-parse HEAD > .mina_git_revision}
+    comment %(Updating submodules)
+    command %(git submodule update)
+    comment %(Using this git commit)
+    command %(git rev-parse HEAD > .mina_git_revision)
     command %{git --no-pager log --format="%aN (%h):%n> %s" -n 1}
-    if fetch(:remove_git_dir)
-      command %{rm -rf .git}
-    end
+    command %(rm -rf .git) if fetch(:remove_git_dir)
   end
 
   desc 'Prints out current revision'
   task :revision do
     ensure!(:deploy_to)
-    command %{cat #{fetch(:current_path)}/.mina_git_revision}
+    command %(cat #{fetch(:current_path)}/.mina_git_revision)
   end
 
   desc 'Ensures local repository is pushed to remote'
   task :ensure_pushed do
     run :local do
-      comment %{Ensuring everything is pushed to git}
+      comment %(Ensuring everything is pushed to git)
       command %{
+        if [ $(git branch --list #{fetch(:branch)} | wc -l) -eq 0 ]; then
+          echo "! #{fetch(:git_local_branch_missing_message)}"
+          exit 1
+        fi
+
+        if [ $(git branch -r --list #{fetch(:remote)}/#{fetch(:branch)} | wc -l) -eq 0 ]; then
+          echo "! #{fetch(:git_remote_branch_missing_message)}"
+          exit 1
+        fi
+
         if [ $(git log #{fetch(:remote)}/#{fetch(:branch)}..#{fetch(:branch)} | wc -l) -ne 0 ]; then
           echo "! #{fetch(:git_not_pushed_message)}"
           exit 1

data/tasks/mina/install.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 desc 'Creates a sample config file.'
 task :init do
   name = Rake.application.name
@@ -10,7 +12,7 @@ task :init do
 
   outfile = './config/deploy.rb'
 
-  if File.exists?(outfile)
+  if File.exist?(outfile)
     print 'deploy.rb already exists, do you want to overwrite it? (y/n) '
 
     exit(8) if $stdin.readline.chomp.downcase != 'y'

data/tasks/mina/rails.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 require 'mina/deploy'
 require 'mina/bundler'
 
 set :rails_env, 'production'
-set :bundle_prefix, -> { %{RAILS_ENV="#{fetch(:rails_env)}" #{fetch(:bundle_bin)} exec} }
+set :bundle_prefix, -> { %(RAILS_ENV="#{fetch(:rails_env)}" #{fetch(:bundle_bin)} exec) }
 set :rake, -> { "#{fetch(:bundle_prefix)} rake" }
 set :rails, -> { "#{fetch(:bundle_prefix)} rails" }
 set :compiled_asset_path, 'public/assets'
@@ -14,8 +16,8 @@ set :shared_dirs, fetch(:shared_dirs, []).push('log', 'tmp/cache', fetch(:compil
 desc 'Starts an interactive console.'
 task :console do
   set :execution_mode, :exec
-  in_path "#{fetch(:current_path)}" do
-    command %{#{fetch(:rails)} console}
+  in_path fetch(:current_path) do
+    command %(#{fetch(:rails)} console)
   end
 end
 
@@ -23,7 +25,7 @@ desc 'Tail log from server'
 task :log do
   set :execution_mode, :exec
   in_path "#{fetch(:shared_path)}/log" do
-    command %{tail -f #{fetch(:rails_env)}.log}
+    command %(tail -f #{fetch(:rails_env)}.log)
   end
 end
 
@@ -32,72 +34,72 @@ namespace :rails do
   task :db_migrate do
     ensure!(:deploy_block, message: "Can't be run outside deploy do block. Please use mina 'rake[db_migrate]' instead")
     if fetch(:force_migrate)
-      comment %{Migrating database}
-      command %{#{fetch(:rake)} db:migrate}
+      comment %(Migrating database)
+      command %(#{fetch(:rake)} db:migrate)
     else
       command check_for_changes_script(
         at: fetch(:migration_dirs),
-        skip: %{echo "-----> DB migrations unchanged; skipping DB migration"},
-        changed: %{echo "-----> Migrating database"
-          #{echo_cmd("#{fetch(:rake)} db:migrate")}}
+        skip: %(echo "-----> DB migrations unchanged; skipping DB migration"),
+        changed: %(echo "-----> Migrating database"
+          #{echo_cmd("#{fetch(:rake)} db:migrate")})
       ), quiet: true
     end
   end
 
   desc 'Create database'
   task :db_create do
-    comment %{Creating database}
-    command %{#{fetch(:rake)} db:create}
+    comment %(Creating database)
+    command %(#{fetch(:rake)} db:create)
   end
 
   desc 'Rollback database'
   task :db_rollback do
-    comment %{Rollbacking database}
-    command %{#{fetch(:rake)} db:rollback}
+    comment %(Rollbacking database)
+    command %(#{fetch(:rake)} db:rollback)
   end
 
   desc 'Precompiles assets (skips if nothing has changed since the last release).'
   task :assets_precompile do
     ensure!(:deploy_block, message: "Can't be run outside deploy do block. Please use mina 'rake[assets_precompile]' instead")
     if fetch(:force_asset_precompile)
-      comment %{Precompiling asset files}
-      command %{#{fetch(:rake)} assets:precompile}
+      comment %(Precompiling asset files)
+      command %(#{fetch(:rake)} assets:precompile)
     else
       command check_for_changes_script(
         at: fetch(:asset_dirs),
-        skip: %{echo "-----> Skipping asset precompilation"},
-        changed: %{echo "-----> Precompiling asset files"
-          #{echo_cmd "#{fetch(:rake)} assets:precompile"}}
+        skip: %(echo "-----> Skipping asset precompilation"),
+        changed: %(echo "-----> Precompiling asset files"
+          #{echo_cmd "#{fetch(:rake)} assets:precompile"})
       ), quiet: true
     end
   end
 
   desc 'Clear older assets'
   task :assets_clean do
-    comment %{Removing older assets}
-    command %{#{fetch(:rake)} assets:clean}
+    comment %(Removing older assets)
+    command %(#{fetch(:rake)} assets:clean)
   end
 
   desc 'DB schema load'
   task :db_schema_load do
-    comment %{DB schema load}
-    command %{#{fetch(:rake)} db:schema:load}
+    comment %(DB schema load)
+    command %(#{fetch(:rake)} db:schema:load)
   end
 end
 
 def check_for_changes_script(options)
   diffs = options[:at].map do |path|
-    %{diff -qrN "#{fetch(:current_path)}/#{path}" "./#{path}" 2>/dev/null}
+    %(diff -qrN "#{fetch(:current_path)}/#{path}" "./#{path}" 2>/dev/null)
   end.join(' && ')
 
-  %{
+  %(
     if #{diffs}
     then
       #{options[:skip]}
     else
       #{options[:changed]}
     fi
-  }
+  )
 end
 
 # Macro used later by :rails, :rake, etc
@@ -107,10 +109,10 @@ make_run_task = lambda { |name, example|
 
     arguments = args[:arguments]
     unless arguments
-      puts %{You need to provide arguments. Try: mina "#{name}[#{example}]"}
+      puts %(You need to provide arguments. Try: mina "#{name}[#{example}]")
       exit 1
     end
-    in_path "#{fetch(:current_path)}" do
+    in_path fetch(:current_path) do
       command %(#{fetch(name)} #{arguments})
     end
   end

data/tasks/mina/rbenv.rb

@@ -1,15 +1,17 @@
-set :rbenv_path, "$HOME/.rbenv"
+# frozen_string_literal: true
+
+set :rbenv_path, '$HOME/.rbenv'
 
 task :'rbenv:load' do
-  comment %{Loading rbenv}
-  command %{export RBENV_ROOT="#{fetch(:rbenv_path)}"}
-  command %{export PATH="#{fetch(:rbenv_path)}/bin:$PATH"}
-  command %{
+  comment %(Loading rbenv)
+  command %(export RBENV_ROOT="#{fetch(:rbenv_path)}")
+  command %(export PATH="#{fetch(:rbenv_path)}/bin:$PATH")
+  command %(
     if ! which rbenv >/dev/null; then
       echo "! rbenv not found"
       echo "! If rbenv is installed, check your :rbenv_path setting."
       exit 1
     fi
-  }
+  )
   command %{eval "$(rbenv init -)"}
 end

data/tasks/mina/rvm.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 set :rvm_use_path, '$HOME/.rvm/scripts/rvm'
 
 task :'rvm:use', :env do |_, args|
@@ -7,33 +9,33 @@ task :'rvm:use', :env do |_, args|
     exit 1
   end
 
-  comment %{Using RVM environment \\\"#{args[:env]}\\\"}
-  command %{
+  comment %(Using RVM environment \\\"#{args[:env]}\\\")
+  command %(
     if [[ ! -s "#{fetch(:rvm_use_path)}" ]]; then
       echo "! Ruby Version Manager not found"
       echo "! If RVM is installed, check your :rvm_use_path setting."
       exit 1
     fi
-  }
-  command %{source #{fetch(:rvm_use_path)}}
-  command %{rvm use "#{args[:env]}" --create}
+  )
+  command %(source #{fetch(:rvm_use_path)})
+  command %(rvm use "#{args[:env]}" --create)
 end
 
 task :'rvm:wrapper', :env, :name, :bin do |_, args|
   unless args[:env] && args[:name] && args[:bin]
-    puts "Task 'rvm:wrapper' needs an RVM environment name, an wrapper name and the binary name as arguments"
+    puts "Task 'rvm:wrapper' needs an RVM environment name, a wrapper name and the binary name as arguments"
     puts "Example: invoke :'rvm:wrapper', 'ruby-1.9.2@myapp,myapp,unicorn_rails'"
     exit 1
   end
 
-  comment %{creating RVM wrapper "#{args[:name]}_#{args[:bin]}" using \\"#{args[:env]}\\"}
-  command %{
+  comment %(creating RVM wrapper "#{args[:name]}_#{args[:bin]}" using \\"#{args[:env]}\\")
+  command %(
     if [[ ! -s "#{fetch(:rvm_use_path)}" ]]; then
       echo "! Ruby Version Manager not found"
       echo "! If RVM is installed, check your :rvm_use_path setting."
       exit 1
     fi
-  }
-  command %{source #{fetch(:rvm_use_path)}}
-  command %{rvm wrapper #{args[:env]} #{args[:name]} #{args[:bin]} || exit 1}
+  )
+  command %(source #{fetch(:rvm_use_path)})
+  command %(rvm wrapper #{args[:env]} #{args[:name]} #{args[:bin]} || exit 1)
 end