heroku_san 4.3.2 → 4.4.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 3a9578dfc90a0553a24f7ec7ee3059d872b6ab98
+  data.tar.gz: 3267d16a4619e35fd9109ede728c98dcd75b6d4b
+SHA512:
+  metadata.gz: 232012170dde11b1fdb6399d9d036a2aec44517182fbb2a77f49bad94c7b5a1361057fe7d1458bca2c9bffa4bef7b7140d848b224063dc8eb7e67554d5e0e0f5
+  data.tar.gz: 00c8e215b7c4fb746e6b8e2d3efb58e86eea8be063704a302b4ee06dba2f01d26096d0b84fe4fc562c6df849daf4136676459dfa52bbb9e62196802a5dd5197d

data/.ruby-version

@@ -1 +1 @@
-ruby-1.9.3-p327
+2.2.4

data/.travis.yml

@@ -2,9 +2,10 @@ language: ruby
 bundler_args: --without development
 script: "bundle exec rake travis"
 rvm:
-  - 1.9.2
-  - 1.9.3
-  - 2.0.0
+  - 2.0
+  - 2.1
+  - 2.2
+  - 2.3
 env:
   global:
     - secure: dAxfEdg/7Cb/G9vkrn/ifdvycbXWtK2ey60JMepOxx9v3QyaqoSY3w5G0QB+4+uyOYmHwtif8tnK3Sa8jbBgqhAlXaxqxOT8WmQKYlhSgwWX4lQe4lUM5jkOkfNHRMRaQvCAn27gNAjdIRU7sb2cU/pm64eAFbU01TejJOM7Aow=

data/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Change Log (curated)
 
+# The Future
+
+  * [https://github.com/fastestforward/heroku_san/releases](https://github.com/fastestforward/heroku_san/releases)
+  * GitHub releases pages will replace the ChangeLog
+
 ## v4.3.0
 
   * Add #ensure_{all|one}_worker(s)_running -- which will restart your web workers until they stay up

data/Gemfile

@@ -5,25 +5,17 @@ gemspec
 
 group :test do
   gem 'aruba'
-  gem 'bundler', '~> 1.1'
+  gem 'bundler'
   gem 'cucumber'
   gem 'godot'
-  gem 'rails', '3.2.7'
+  gem 'rails'
   gem 'rake'
-  gem 'rspec', '~> 2.14'
+  gem 'rspec'
   gem 'sqlite3'
   gem 'pg'
 end
 
 group :development do
   gem 'git-smart'
-  gem 'guard'
-  gem 'guard-bundler'
-  gem 'guard-cucumber'
-  gem 'guard-rspec'
-  gem 'rb-fchange', :require => false
-  gem 'rb-fsevent', :require => false
-  gem 'rb-inotify', :require => false
-  gem 'terminal-notifier-guard'
   gem 'travis', '~> 1.5.6'
 end

data/README.md

@@ -3,10 +3,11 @@ Helpful rake tasks for Heroku.
 
 [![Build Status](https://secure.travis-ci.org/fastestforward/heroku_san.png)](http://travis-ci.org/fastestforward/heroku_san)
 [![Code Climate](https://codeclimate.com/github/fastestforward/heroku_san.png)](https://codeclimate.com/github/fastestforward/heroku_san)
+[![Gemnasium](https://gemnasium.com/fastestforward/heroku_san.png)](https://gemnasium.com/fastestforward/heroku_san)
 
 ## Install
 
-### Rails 3
+### Rails 3+
 
 Add this to your `Gemfile`:
 
@@ -62,7 +63,7 @@ Update your `Rakefile`:
 
 In `config/heroku.yml` you will need to add the Heroku apps that you would like to attach to this project. You can generate this file by running:
 
-### Rails 3
+### Rails 3+
 
 ```sh
   rails generate heroku_san

data/features/shell_execution.feature

@@ -1,13 +1,13 @@
 @slow_process @announce-cmd
 Feature: heroku_san can shell out to heroku without errors
 
-  Scenario: Bundling a ruby 2.0 project
+  Scenario: Bundling a ruby 2.2.4 project
     Given I run `mkdir -p ruby2test`
     And I cd to "ruby2test"
     And I write to "Gemfile" with:
     """
       source "https://rubygems.org"
-      ruby '2.0.0'
+      ruby '2.2.4'
       gem 'heroku_san', :path => '../../../.'
     """
 
@@ -31,9 +31,7 @@ Feature: heroku_san can shell out to heroku without errors
     """
     #!/usr/bin/env bash
 
-    [[ -s "$HOME/.rvm/scripts/rvm" ]] && source "$HOME/.rvm/scripts/rvm"
-
-    rvm use 2.0.0
+    rbenv local 2.2.4
     bundle install
 
     ruby get_heroku_version.rb

data/features/step_definitions/remote_steps.rb

@@ -55,7 +55,7 @@ When /^I add heroku_san to the rails Gemfile$/ do
   overwrite_file 'Gemfile', <<EOT.strip_heredoc
     source 'https://rubygems.org'
     ruby '#{ruby_version}'
-    gem 'rails', '3.2.7'
+    gem 'rails', '4.2.6'
     gem 'pg'
     group :development, :test do
       gem 'heroku_san', :path => '../../../.'
@@ -177,12 +177,12 @@ end
 
 When /^I deploy my project$/ do
   run_clean 'rake test_app deploy'
-  assert_partial_output "http://#{@app}.herokuapp.com deployed to Heroku", all_output
+  assert_partial_output "https://#{@app}.herokuapp.com/ deployed to Heroku", all_output
 end
 
 When /^I deploy to tag "([^"]*)"$/ do |tag|
   run_clean "rake test_app deploy[#{tag}]"
-  assert_partial_output "http://#{@app}.herokuapp.com deployed to Heroku", all_output
+  assert_partial_output "https://#{@app}.herokuapp.com/ deployed to Heroku", all_output
 end
 
 When /^I list all apps on Heroku$/ do
@@ -196,18 +196,17 @@ When /^I list all apps on Heroku$/ do
 end
 
 When /^I install an addon$/ do
-  # Install the campfire addon.
   overwrite_file 'config/heroku.yml', <<END_CONFIG.strip_heredoc
     test_app:
       app: #{@app}
       addons:
-        - heroku-postgresql:dev
+        - heroku-postgresql:hobby-dev
 
 END_CONFIG
 
   output = run_clean 'rake test_app heroku:addons'
   # The output should show the new one ...
-  assert_partial_output "heroku-postgresql:dev", output
+  assert_partial_output "heroku-postgresql:hobby-dev", output
 end
 
 Then /^(?:heroku_san|issue \d+) (?:is green|has been fixed)$/ do
@@ -236,5 +235,5 @@ EOT
 end
 
 def ruby_version
-  ENV['TRAVIS_RUBY_VERSION'] || '1.9.3'
+  ENV['TRAVIS_RUBY_VERSION'] || '2.2.4'
 end

data/lib/heroku_san/api.rb

@@ -9,7 +9,7 @@ module HerokuSan
     def sh(app, *command)
       preflight_check_for_cli
 
-      cmd = (command + ['--app', app]).compact
+      cmd = (command + ['--app', app, "--exit-code"]).compact
 
       show_command = cmd.join(' ')
       $stderr.puts show_command if @debug

data/lib/heroku_san/version.rb

@@ -1,3 +1,3 @@
 module HerokuSan
-  VERSION = "4.3.2"
+  VERSION = "4.4.0"
 end

data/spec/heroku_san/api_spec.rb

@@ -5,22 +5,22 @@ module HerokuSan
 describe HerokuSan::API do
   subject(:api) { HerokuSan::API.new(:api_key => 'key', :double => true)}
   it "is a proxy to the Heroku::API" do
-    Heroku::API.any_instance.should_receive(:api_method).with(1, 2, {:arg => 3}) {true}
-    api.api_method(1, 2, {:arg => 3}).should be_true
+    expect_any_instance_of(Heroku::API).to receive(:api_method).with(1, 2, {:arg => 3}) {true}
+    expect(api.api_method(1, 2, {:arg => 3})).to be_truthy
   end
 
   it "reports Excon errors in a more human readable format" do
     error_message = 'Name is already taken'
     status_message = '000 Status'
     response = double("Response", :body => %Q[{"error":"#{error_message}"}], :headers => {'Status' => status_message})
-    Heroku::API.any_instance.should_receive(:api_method).and_raise(Heroku::API::Errors::ErrorWithResponse.new("excon message", response))
+    expect_any_instance_of(Heroku::API).to receive(:api_method).and_raise(Heroku::API::Errors::ErrorWithResponse.new("excon message", response))
 
-    $stderr.should_receive(:puts).with("\nHeroku API ERROR: #{status_message} (#{error_message})\n\n")
+    expect($stderr).to receive(:puts).with("\nHeroku API ERROR: #{status_message} (#{error_message})\n\n")
 
     expect {
       api.api_method
     }.to raise_error(Heroku::API::Errors::ErrorWithResponse, "excon message") {|error|
-      error.backtrace.should == []
+      expect(error.backtrace).to eq []
     }
   end
 end

data/spec/heroku_san/application_spec.rb

@@ -6,7 +6,7 @@ module HerokuSan
     let(:response) { double }
 
     before do
-      stage.heroku.stub(:get_ps).with(stage.app) { response }
+      allow(stage.heroku).to receive(:get_ps).with(stage.app) { response }
     end
 
     describe "#ensure_one_worker_running" do
@@ -29,8 +29,8 @@ module HerokuSan
       it "should block until at least one worker is running, and restart any crashed workers it sees" do
 
         with_app(stage, 'name' => stage.app) do |app_data|
-          response.should_receive(:body).twice.and_return(none_running, one_running_with_crash)
-          stage.heroku.should_receive(:post_ps_restart).with(stage.app, ps: 'web.1')
+          expect(response).to receive(:body).twice.and_return(none_running, one_running_with_crash)
+          expect(stage.heroku).to receive(:post_ps_restart).with(stage.app, ps: 'web.1')
 
           stage.ensure_one_worker_running
         end
@@ -69,9 +69,9 @@ module HerokuSan
 
       it "should block until all workers are running, and restart any crashed workers it sees" do
         with_app(stage, 'name' => stage.app) do |app_data|
-          response.should_receive(:body).exactly(4).times.and_return(some_crashes, some_restarting, one_crash, all_up)
-          stage.heroku.should_receive(:post_ps_restart).with(stage.app, ps: 'worker.1').twice
-          stage.heroku.should_receive(:post_ps_restart).with(stage.app, ps: 'web.1').once
+          expect(response).to receive(:body).exactly(4).times.and_return(some_crashes, some_restarting, one_crash, all_up)
+          expect(stage.heroku).to receive(:post_ps_restart).with(stage.app, ps: 'worker.1').twice
+          expect(stage.heroku).to receive(:post_ps_restart).with(stage.app, ps: 'web.1').once
 
           stage.ensure_all_workers_running
         end

data/spec/heroku_san/configuration_spec.rb

@@ -8,17 +8,17 @@ describe HerokuSan::Configuration do
   describe "#stages" do
     it "creates a configuration hash" do
       configuration.configuration = {'production' => {}}
-      configuration.stages.should == {
+      expect(configuration.stages).to eq(
           'production' => Factory::Stage.build('production', 'deploy' => HerokuSan::Deploy::Rails)
-      }
+      )
     end
 
     it "configures the deploy strategy" do
       configurable.options = {'deploy' => HerokuSan::Deploy::Base}
       configuration.configuration = {'production' => {}}
-      configuration.stages.should == {
+      expect(configuration.stages).to eq(
           'production' => Factory::Stage.build('production', 'deploy' => HerokuSan::Deploy::Base)
-      }
+      )
     end
   end
 
@@ -27,15 +27,15 @@ describe HerokuSan::Configuration do
       it "creates a new file using the example file" do
         Dir.mktmpdir do |dir|
           configurable.config_file = tmp_config_file = File.join(dir, 'config.yml')
-          FileUtils.should_receive(:cp).with(configuration.template, tmp_config_file)
-          configuration.generate_config.should be_true
+          expect(FileUtils).to receive(:cp).with(configuration.template, tmp_config_file)
+          expect(configuration.generate_config).to be_truthy
         end
       end
 
       it "does not overwrite an existing file" do
-        FileUtils.should_not_receive(:cp)
+        expect(FileUtils).not_to receive(:cp)
         configurable.config_file = fixture("example.yml")
-        configuration.generate_config.should be_false
+        expect(configuration.generate_config).to be_falsey
       end
     end
   end

data/spec/heroku_san/deploy/base_spec.rb

@@ -7,25 +7,25 @@ module HerokuSan
       
       it "calls push" do
         subject = described_class.new(stage)
-        stage.should_receive(:push).with(nil, nil)
+        expect(stage).to receive(:push).with(nil, nil)
         subject.deploy
       end
       
       it "calls push(sha)" do
         subject = described_class.new(stage, 'sha')
-        stage.should_receive(:push).with('sha', nil)
+        expect(stage).to receive(:push).with('sha', nil)
         subject.deploy
       end
       
       it "calls push(nil, :force)" do
         subject = described_class.new(stage, nil, :force)
-        stage.should_receive(:push).with(nil, :force)
+        expect(stage).to receive(:push).with(nil, :force)
         subject.deploy
       end
 
       it "calls push(sha, :force)" do
         subject = described_class.new(stage, 'sha', :force)
-        stage.should_receive(:push).with('sha', :force)
+        expect(stage).to receive(:push).with('sha', :force)
         subject.deploy
       end
     end

data/spec/heroku_san/deploy/rails_spec.rb

@@ -7,9 +7,9 @@ module HerokuSan
 
       it "calls push, rake db:migrate & restart" do
         subject = described_class.new(stage, {})
-        stage.should_receive(:push) { "pushed" } # "mock" super
-        stage.should_receive(:run).with('rake db:migrate') { "migrated" }
-        stage.should_receive(:restart) { "restarted" }
+        expect(stage).to receive(:push) { "pushed" } # "mock" super
+        expect(stage).to receive(:run).with('rake db:migrate') { "migrated" }
+        expect(stage).to receive(:restart) { "restarted" }
         subject.deploy
       end
     end

data/spec/heroku_san/git_spec.rb

@@ -6,81 +6,81 @@ class GitTest; include HerokuSan::Git; end
 describe GitTest do
   describe "#git_push" do    
     it "pushes to heroku" do
-      subject.should_receive(:sh).with("git update-ref refs/heroku_san/deploy HEAD^{commit}")
-      subject.should_receive(:sh).with("git push git@heroku.com:awesomeapp.git  refs/heroku_san/deploy:refs/heads/master")
-      subject.should_receive(:sh).with("git update-ref -d refs/heroku_san/deploy")
+      expect(subject).to receive(:sh).with("git update-ref refs/heroku_san/deploy HEAD^{commit}")
+      expect(subject).to receive(:sh).with("git push git@heroku.com:awesomeapp.git  refs/heroku_san/deploy:refs/heads/master")
+      expect(subject).to receive(:sh).with("git update-ref -d refs/heroku_san/deploy")
       subject.git_push(nil, 'git@heroku.com:awesomeapp.git')
     end
     
     it "pushes a specific commit to heroku" do
-      subject.should_receive(:sh).with("git update-ref refs/heroku_san/deploy kommit^{commit}")
-      subject.should_receive(:sh).with("git push git@heroku.com:awesomeapp.git  refs/heroku_san/deploy:refs/heads/master")
-      subject.should_receive(:sh).with("git update-ref -d refs/heroku_san/deploy")
+      expect(subject).to receive(:sh).with("git update-ref refs/heroku_san/deploy kommit^{commit}")
+      expect(subject).to receive(:sh).with("git push git@heroku.com:awesomeapp.git  refs/heroku_san/deploy:refs/heads/master")
+      expect(subject).to receive(:sh).with("git update-ref -d refs/heroku_san/deploy")
       subject.git_push('kommit', 'git@heroku.com:awesomeapp.git')
     end
     
     it "includes options, too" do
-      subject.should_receive(:sh).with("git update-ref refs/heroku_san/deploy HEAD^{commit}")
-      subject.should_receive(:sh).with("git push git@heroku.com:awesomeapp.git --force -v refs/heroku_san/deploy:refs/heads/master")
-      subject.should_receive(:sh).with("git update-ref -d refs/heroku_san/deploy")
+      expect(subject).to receive(:sh).with("git update-ref refs/heroku_san/deploy HEAD^{commit}")
+      expect(subject).to receive(:sh).with("git push git@heroku.com:awesomeapp.git --force -v refs/heroku_san/deploy:refs/heads/master")
+      expect(subject).to receive(:sh).with("git update-ref -d refs/heroku_san/deploy")
       subject.git_push(nil, 'git@heroku.com:awesomeapp.git', %w[--force -v])
     end
 
     it "propagates any errors, but still cleans up" do
-      subject.should_receive(:sh).with("git update-ref refs/heroku_san/deploy HEAD^{commit}")
-      subject.should_receive(:sh).with("git push git@heroku.com:awesomeapp.git  refs/heroku_san/deploy:refs/heads/master").and_raise
-      subject.should_receive(:sh).with("git update-ref -d refs/heroku_san/deploy")
-      expect { subject.git_push(nil, 'git@heroku.com:awesomeapp.git') }.to raise_error
+      expect(subject).to receive(:sh).with("git update-ref refs/heroku_san/deploy HEAD^{commit}")
+      expect(subject).to receive(:sh).with("git push git@heroku.com:awesomeapp.git  refs/heroku_san/deploy:refs/heads/master").and_raise
+      expect(subject).to receive(:sh).with("git update-ref -d refs/heroku_san/deploy")
+      expect { subject.git_push(nil, 'git@heroku.com:awesomeapp.git') }.to raise_error StandardError
     end
   end
 
   describe "#git_tag" do
     it "returns the latest tag that matches the pattern" do
-      subject.should_receive("`").with("git tag -l 'pattern*'") { "x\n\y\n\z\n" }
-      subject.git_tag('pattern*').should == "z"
+      expect(subject).to receive("`").with("git tag -l 'pattern*'") { "x\n\y\n\z\n" }
+      expect(subject.git_tag('pattern*')).to eq "z"
     end
 
     it "raises exception if no tags match the pattern" do
-      subject.should_receive("`").with("git tag -l 'pattern*'") { "\n" }
+      expect(subject).to receive("`").with("git tag -l 'pattern*'") { "\n" }
       expect {
         subject.git_tag('pattern*')
       }.to raise_error(HerokuSan::Git::NoTagFoundError)
     end
 
     it "returns nil for a nil glob" do
-      subject.should_not_receive("`").with("git tag -l ''") { "\n" }
-      subject.git_tag(nil).should == nil
+      expect(subject).not_to receive("`").with("git tag -l ''") { "\n" }
+      expect(subject.git_tag(nil)).to be_nil
     end
   end
   
   describe "#git_rev_parse" do
     it "returns the rev based on the tag" do
-      subject.should_receive("`").with("git rev-parse prod/1234567890") { "sha\n" }
-      subject.git_rev_parse('prod/1234567890').should == "sha"
+      expect(subject).to receive("`").with("git rev-parse prod/1234567890") { "sha\n" }
+      expect(subject.git_rev_parse('prod/1234567890')).to eq "sha"
     end
 
     it "returns nil for a blank tag" do
-      subject.should_not_receive("`").with("git rev-parse ") { "\n" }
-      subject.git_rev_parse(nil).should == nil
+      expect(subject).not_to receive("`").with("git rev-parse ") { "\n" }
+      expect(subject.git_rev_parse(nil)).to be_nil
     end
   end
 
   describe "#git_revision" do
     it "returns the current revision of the repository (on Heroku)" do
-      subject.should_receive("`").with("git ls-remote --heads staging master") { "sha\n" }
-      subject.git_revision('staging').should == 'sha'
+      expect(subject).to receive("`").with("git ls-remote --heads staging master") { "sha\n" }
+      expect(subject.git_revision('staging')).to eq 'sha'
     end
     
     it "returns nil if there is no revision (i.e. not deployed yet)" do
-      subject.should_receive("`").with("git ls-remote --heads staging master") { "\n" }
-      subject.git_revision('staging').should == nil
+      expect(subject).to receive("`").with("git ls-remote --heads staging master") { "\n" }
+      expect(subject.git_revision('staging')).to be_nil
     end
   end
   
   describe "#git_named_rev" do
     it "returns symbolic names for given rev" do
-      subject.should_receive("`").with("git name-rev sha") {"sha production/123456\n"}
-      subject.git_named_rev('sha').should == 'sha production/123456'
+      expect(subject).to receive("`").with("git name-rev sha") {"sha production/123456\n"}
+      expect(subject.git_named_rev('sha')).to eq 'sha production/123456'
     end
   end
 end

data/spec/heroku_san/parser_spec.rb

@@ -11,10 +11,10 @@ describe HerokuSan::Parser do
       it "returns a list of apps" do
         parser.parse(parseable)
 
-        parseable.configuration.keys.should =~ %w[production staging demo]
-        parseable.configuration['production'].should == {'app' => 'awesomeapp', 'tag' => 'production/*', 'config' => {'BUNDLE_WITHOUT' => 'development:test', 'GOOGLE_ANALYTICS' => 'UA-12345678-1'}}
-        parseable.configuration['staging'].should == {'app' => 'awesomeapp-staging', 'stack' => 'bamboo-ree-1.8.7', 'config' => {'BUNDLE_WITHOUT' => 'development:test'}}
-        parseable.configuration['demo'].should == {'app' => 'awesomeapp-demo', 'stack' => 'cedar', 'config' => {'BUNDLE_WITHOUT' => 'development:test'}}
+        expect(parseable.configuration.keys).to match %w[production staging demo]
+        expect(parseable.configuration['production']).to eq({'app' => 'awesomeapp', 'tag' => 'production/*', 'config' => {'BUNDLE_WITHOUT' => 'development:test', 'GOOGLE_ANALYTICS' => 'UA-12345678-1'}})
+        expect(parseable.configuration['staging']).to eq({'app' => 'awesomeapp-staging', 'stack' => 'bamboo-ree-1.8.7', 'config' => {'BUNDLE_WITHOUT' => 'development:test'}})
+        expect(parseable.configuration['demo']).to eq({'app' => 'awesomeapp-demo', 'stack' => 'cedar', 'config' => {'BUNDLE_WITHOUT' => 'development:test'}})
       end
     end
 
@@ -24,12 +24,12 @@ describe HerokuSan::Parser do
       it "returns a list of apps" do
         parser.parse(parseable)
 
-        parseable.configuration.keys.should =~ %w[production staging demo]
-        parseable.configuration.should == {
+        expect(parseable.configuration.keys).to match %w[production staging demo]
+        expect(parseable.configuration).to eq({
             'production' => {'app' => 'awesomeapp', 'config' => {}},
             'staging' => {'app' => 'awesomeapp-staging', 'config' => {}},
             'demo' => {'app' => 'awesomeapp-demo', 'config' => {}}
-        }
+        })
       end
     end
   end
@@ -63,7 +63,7 @@ describe HerokuSan::Parser do
       let(:parseable) { double :external_configuration => nil }
 
       it "doesn't change prod_config" do
-        prod_config.should_not_receive :merge!
+        expect(prod_config).not_to receive :merge!
         parser.merge_external_config! parseable, stages
       end
     end
@@ -71,18 +71,18 @@ describe HerokuSan::Parser do
     context "with extra" do
       let(:parseable) { double :external_configuration => 'config_repos' }
       before(:each) do
-        parser.should_receive(:git_clone).with('config_repos', anything)
-        parser.should_receive(:parse_yaml).and_return(extras)
+        expect(parser).to receive(:git_clone).with('config_repos', anything)
+        expect(parser).to receive(:parse_yaml).and_return(extras)
       end
 
       it "merges extra configuration bits" do
-        prod_config.should_receive(:merge!).with extras['production']
+        expect(prod_config).to receive(:merge!).with extras['production']
         parser.merge_external_config! parseable, [stages.first]
       end
 
       it "overrides the main configuration" do
         parser.merge_external_config! parseable, [stages.last]
-        staging_config.should == {"EXTRA" => "foo"}
+        expect(staging_config).to eq("EXTRA" => "foo")
       end
     end
   end

data/spec/heroku_san/project_spec.rb

@@ -14,32 +14,32 @@ describe HerokuSan::Project do
 
   describe "#apps constructs the deploy list" do
     it "appends known shorthands to apps" do
-      heroku_san.apps.should == []
+      expect(heroku_san.apps).to eq []
       heroku_san << 'production'
-      heroku_san.apps.should == %w[production]
+      expect(heroku_san.apps).to eq %w[production]
       heroku_san << 'staging'
-      heroku_san.apps.should == %w[production staging]
+      expect(heroku_san.apps).to eq %w[production staging]
       heroku_san << 'unknown'
-      heroku_san.apps.should == %w[production staging]
+      expect(heroku_san.apps).to eq %w[production staging]
     end
   
     it "appends .all (or any array)" do
       heroku_san << heroku_san.all
-      heroku_san.apps.should == heroku_san.all
+      expect(heroku_san.apps).to eq heroku_san.all
     end
   
     describe "extra (default) behaviors" do
       specify "on a git branch that matches an app name" do
-        heroku_san.should_receive(:git_active_branch) { "staging" }
-        $stdout.should_receive(:puts).with("Defaulting to 'staging' as it matches the current branch")
+        expect(heroku_san).to receive(:git_active_branch) { "staging" }
+        expect($stdout).to receive(:puts).with("Defaulting to 'staging' as it matches the current branch")
         expect {
-          heroku_san.apps.should == %w[staging]
+          expect(heroku_san.apps).to eq %w[staging]
         }.to change{heroku_san.instance_variable_get('@apps')}.from([]).to(%w[staging])
       end
-    
+
       specify "on a git branch that doesn't matches an app name" do
-        heroku_san.should_receive(:git_active_branch) { "master" }
-        heroku_san.apps.should == %w[]
+        expect(heroku_san).to receive(:git_active_branch) { "master" }
+        expect(heroku_san.apps).to eq %w[]
       end
     
       context "with only a single configured app" do        
@@ -51,9 +51,9 @@ describe HerokuSan::Project do
         end
 
         it "returns the app" do
-          $stdout.should_receive(:puts).with('Defaulting to "production" since only one app is defined')
+          expect($stdout).to receive(:puts).with('Defaulting to "production" since only one app is defined')
           expect {
-            heroku_san.apps.should == %w[production]
+            expect(heroku_san.apps).to eq %w[production]
           }.to change{heroku_san.instance_variable_get('@apps')}.from([]).to(%w[production])
         end
       end
@@ -68,7 +68,7 @@ describe HerokuSan::Project do
     it "yields to a block with args" do
       heroku_san << 'production'
       block = double('block')
-      block.should_receive(:action).with(heroku_san['production'])
+      expect(block).to receive(:action).with(heroku_san['production'])
       heroku_san.each_app do |stage|
         block.action(stage)
       end
@@ -78,7 +78,7 @@ describe HerokuSan::Project do
   describe "#[]" do
     it "returns a config section" do
       heroku_san.all.each do |app|
-        heroku_san[app].should be_a HerokuSan::Stage
+        expect(heroku_san[app]).to be_a HerokuSan::Stage
       end
     end
   end

data/spec/heroku_san/stage_spec.rb

@@ -7,7 +7,7 @@ describe HerokuSan::Stage do
   include HerokuSan::Git
   subject { Factory::Stage.build('production', {"deploy" => HerokuSan::Deploy::Rails, "app" => "awesomeapp", "stack" => "cedar"})}
   before do
-    HerokuSan::API.any_instance.stub(:preflight_check_for_cli)
+    allow_any_instance_of(HerokuSan::API).to receive(:preflight_check_for_cli)
   end
 
   context "initializes" do
@@ -19,17 +19,17 @@ describe HerokuSan::Stage do
        "addons"=> ['one:addon', 'two:addons']
       })}
 
-    its(:name)   { should == 'production' }
-    its(:app)    { should == 'awesomeapp-demo' }
-    its(:stack)  { should == 'cedar' }
-    its(:tag)    { should == "demo/*" }
-    its(:config) { should == {"BUNDLE_WITHOUT"=>"development:test"} }
-    its(:repo)   { should == 'git@heroku.com:awesomeapp-demo.git' }
-    its(:addons) { should == ['one:addon', 'two:addons'] }
+    it { expect(subject.name).to eq 'production' }
+    it { expect(subject.app).to eq 'awesomeapp-demo' }
+    it { expect(subject.stack).to eq 'cedar' }
+    it { expect(subject.tag).to eq "demo/*" }
+    it { expect(subject.config).to eq("BUNDLE_WITHOUT"=>"development:test") }
+    it { expect(subject.repo).to eq 'git@heroku.com:awesomeapp-demo.git' }
+    it { expect(subject.addons).to eq ['one:addon', 'two:addons'] }
   end
   
   describe "#app" do
-    its(:app) { should == 'awesomeapp'}
+    it { expect(subject.app).to eq 'awesomeapp'}
     context "blank app" do
       subject { Factory::Stage.build('production') }
       it "should raise an error" do
@@ -42,13 +42,13 @@ describe HerokuSan::Stage do
     it "returns the name of the stack from Heroku" do
       subject = Factory::Stage.build('production', {"app" => "awesomeapp"})
       with_app(subject, 'name' => subject.app) do |app_data|
-        subject.stack.should == 'bamboo-mri-1.9.2'
+        expect(subject.stack).to eq 'bamboo-mri-1.9.2'
       end
     end
   
     it "returns the stack name from the config when it is set there" do
       subject = Factory::Stage.build('production', {"app" => "awesomeapp", "stack" => "cedar"})
-      subject.stack.should == 'cedar'
+      expect(subject.stack).to eq 'cedar'
     end
   end
 
@@ -56,7 +56,7 @@ describe HerokuSan::Stage do
     subject { Factory::Stage.build('production', {'addons' => addons}) }
     context 'default' do
       let(:addons) { nil }
-      its(:addons) { should == [] }
+      it { expect(subject.addons).to eq [] }
     end
     context 'nested' do
       # This is for when you do:
@@ -68,37 +68,37 @@ describe HerokuSan::Stage do
       #   - *default_addons
       #   - other
       let(:addons) { [ ['a', 'b'], 'other' ] }
-      its(:addons) { should == [ 'a', 'b', 'other' ] }
+      it { expect(subject.addons).to eq [ 'a', 'b', 'other' ] }
     end
   end
 
   describe "#run" do
     it "runs commands using the new cedar format" do
-      subject.heroku.should_receive(:system).with("heroku", "run", "worker foo bar bleh", "--app", "awesomeapp") { true }
+      expect(subject.heroku).to receive(:system).with("heroku", "run", "worker foo bar bleh", "--app", "awesomeapp", "--exit-code") { true }
       subject.run 'worker foo bar bleh'
     end
   end
 
   describe "#push" do
     it "deploys to heroku" do
-      subject.should_receive(:git_parsed_tag).with(nil) {'tag'}
-      subject.should_receive(:git_push).with('tag', subject.repo, [])
+      expect(subject).to receive(:git_parsed_tag).with(nil) {'tag'}
+      expect(subject).to receive(:git_push).with('tag', subject.repo, [])
       subject.push
     end
     
     it "deploys with a custom sha" do
-      subject.should_receive(:git_push).with('deadbeef', subject.repo, [])
+      expect(subject).to receive(:git_push).with('deadbeef', subject.repo, [])
       subject.push('deadbeef')
     end
     
     it "deploys with --force" do
-      subject.should_receive(:git_parsed_tag).with(nil) {'tag'}
-      subject.should_receive(:git_push).with('tag', subject.repo, %w[--force])
+      expect(subject).to receive(:git_parsed_tag).with(nil) {'tag'}
+      expect(subject).to receive(:git_push).with('tag', subject.repo, %w[--force])
       subject.push(nil, :force)
     end
     
     it "deploys with a custom sha & --force" do
-      subject.should_receive(:git_push).with('deadbeef', subject.repo, %w[--force])
+      expect(subject).to receive(:git_push).with('deadbeef', subject.repo, %w[--force])
       subject.push('deadbeef', :force)
     end
   end
@@ -106,8 +106,8 @@ describe HerokuSan::Stage do
   describe "#migrate" do
     it "runs rake db:migrate" do
       with_app(subject, 'name' => subject.app) do |app_data|
-        subject.should_receive(:run).with('rake db:migrate').and_return 'output:'
-        subject.migrate.should == "restarted"
+        expect(subject).to receive(:run).with('rake db:migrate').and_return 'output:'
+        expect(subject.migrate).to eq "restarted"
       end
     end
   end
@@ -115,7 +115,7 @@ describe HerokuSan::Stage do
   describe "#deploy" do
     context "using the default strategy" do
       it "(rails) pushes & migrates" do
-        HerokuSan::Deploy::Rails.any_instance.should_receive(:deploy)
+        allow_any_instance_of(HerokuSan::Deploy::Rails).to receive(:deploy)
         subject.deploy
       end
     end
@@ -126,7 +126,7 @@ describe HerokuSan::Stage do
       end
       subject = Factory::Stage.build('test', {"app" => "awesomeapp", "deploy" => TestDeployStrategy})
       it "(custom) calls deploy" do
-        TestDeployStrategy.any_instance.should_receive(:deploy)
+        expect_any_instance_of(TestDeployStrategy).to receive(:deploy)
         subject.deploy
       end
     end
@@ -135,13 +135,13 @@ describe HerokuSan::Stage do
   describe "#maintenance" do
     it ":on" do
       with_app(subject, 'name' => subject.app )do |app_data|
-        subject.maintenance(:on).status.should == 200
+        expect(subject.maintenance(:on).status).to eq 200
       end
     end
 
     it ":off" do
       with_app(subject, 'name' => subject.app) do |app_data|
-        subject.maintenance(:off).status.should.should == 200
+        expect(subject.maintenance(:off).status).to eq 200
       end
     end
     
@@ -154,9 +154,9 @@ describe HerokuSan::Stage do
     context "with a block" do
       it "wraps it in a maintenance mode" do
         with_app(subject, 'name' => subject.app) do |app_data|
-          subject.heroku.should_receive(:post_app_maintenance).with(subject.app, '1').ordered
-          reactor = double("Reactor"); reactor.should_receive(:scram).with(:now).ordered
-          subject.heroku.should_receive(:post_app_maintenance).with(subject.app, '0').ordered
+          expect(subject.heroku).to receive(:post_app_maintenance).with(subject.app, '1').ordered
+          reactor = double("Reactor"); expect(reactor).to receive(:scram).with(:now).ordered
+          expect(subject.heroku).to receive(:post_app_maintenance).with(subject.app, '0').ordered
           
           subject.maintenance {reactor.scram(:now)} 
         end
@@ -164,11 +164,11 @@ describe HerokuSan::Stage do
 
       it "ensures that maintenance mode is turned off" do
         with_app(subject, 'name' => subject.app) do |app_data|
-          subject.heroku.should_receive(:post_app_maintenance).with(subject.app, '1').ordered
-          reactor = double("Reactor"); reactor.should_receive(:scram).and_raise(RuntimeError)
-          subject.heroku.should_receive(:post_app_maintenance).with(subject.app, '0').ordered
+          expect(subject.heroku).to receive(:post_app_maintenance).with(subject.app, '1').ordered
+          reactor = double("Reactor"); expect(reactor).to receive(:scram).and_raise(RuntimeError)
+          expect(subject.heroku).to receive(:post_app_maintenance).with(subject.app, '0').ordered
           
-          expect do subject.maintenance {reactor.scram(:now)} end.to raise_error
+          expect do subject.maintenance {reactor.scram(:now)} end.to raise_error StandardError
         end
       end
     end
@@ -180,30 +180,30 @@ describe HerokuSan::Stage do
     end
 
     it "uses the provided name" do
-      (@app = subject.create).should == 'awesomeapp'
+      expect((@app = subject.create)).to eq 'awesomeapp'
     end
 
     it "creates an app on heroku" do
       subject = Factory::Stage.build('production')
-      (@app = subject.create).should =~ /generated-name-\d+/
+      expect(@app = subject.create).to match /generated-name-\d+/
     end
 
     it "uses the default stack if none is given" do
       subject = Factory::Stage.build('production')
-      (@app = subject.create).should =~ /generated-name-\d+/
-      subject.heroku.get_stack(@app).body.detect{|stack| stack['current']}['name'].should == 'bamboo-mri-1.9.2'
+      expect(@app = subject.create).to match /generated-name-\d+/
+      expect(subject.heroku.get_stack(@app).body.detect{|stack| stack['current']}['name']).to eq 'bamboo-mri-1.9.2'
     end
 
     it "uses the stack from the config" do
-      (@app = subject.create).should == 'awesomeapp'
-      subject.heroku.get_stack(@app).body.detect{|stack| stack['current']}['name'].should == 'cedar'
+      expect(@app = subject.create).to eq 'awesomeapp'
+      expect(subject.heroku.get_stack(@app).body.detect{|stack| stack['current']}['name']).to eq 'cedar'
     end
   end
   
   describe "#long_config" do
     it "returns the remote config" do
       with_app(subject, 'name' => subject.app) do |app_data|
-        subject.long_config.should == STOCK_CONFIG
+        expect(subject.long_config).to eq STOCK_CONFIG
       end
     end
   end
@@ -212,14 +212,14 @@ describe HerokuSan::Stage do
     it "updates the configuration settings on Heroku" do
       subject = Factory::Stage.build('test', {"app" => "awesomeapp", "config" => {'FOO' => 'bar', 'DOG' => 'emu'}})
       with_app(subject, 'name' => subject.app) do |app_data|
-        subject.push_config.should == STOCK_CONFIG.merge('FOO' => 'bar', 'DOG' => 'emu')
+        expect(subject.push_config).to eq STOCK_CONFIG.merge('FOO' => 'bar', 'DOG' => 'emu')
       end
     end
 
     it "pushes the options hash" do
       subject = Factory::Stage.build('test', {"app" => "awesomeapp", "config" => {'FOO' => 'bar', 'DOG' => 'emu'}})
       with_app(subject, 'name' => subject.app) do |app_data|
-        subject.push_config('RACK_ENV' => 'magic').should == STOCK_CONFIG.merge('RACK_ENV' => 'magic')
+        expect(subject.push_config('RACK_ENV' => 'magic')).to eq STOCK_CONFIG.merge('RACK_ENV' => 'magic')
       end
     end
   end
@@ -227,41 +227,41 @@ describe HerokuSan::Stage do
   describe "#restart" do
     it "restarts an app" do
       with_app(subject, 'name' => subject.app) do |app_data|
-        subject.restart.should == 'restarted'
+        expect(subject.restart).to eq 'restarted'
       end
     end
   end
   
   describe "#logs" do
     it "returns log files" do
-      subject.heroku.should_receive(:system).with("heroku", "logs", "--app", "awesomeapp") { true }
+      expect(subject.heroku).to receive(:system).with("heroku", "logs", "--app", "awesomeapp", "--exit-code") { true }
       subject.logs
     end
 
     it "tails log files" do
-      subject.heroku.should_receive(:system).with("heroku", "logs", "--tail", "--app", "awesomeapp") { true }
+      expect(subject.heroku).to receive(:system).with("heroku", "logs", "--tail", "--app", "awesomeapp", "--exit-code") { true }
       subject.logs(:tail)
     end
   end
 
   describe "#revision" do
     it "returns the named remote revision for the stage" do
-      subject.should_receive(:git_revision).with(subject.repo) {"sha"}
-      subject.should_receive(:git_named_rev).with('sha') {"sha production/123456"}
-      subject.revision.should == 'sha production/123456'
+      expect(subject).to receive(:git_revision).with(subject.repo) {"sha"}
+      expect(subject).to receive(:git_named_rev).with('sha') {"sha production/123456"}
+      expect(subject.revision).to eq 'sha production/123456'
     end
 
     it "returns nil if the stage has never been deployed" do
-      subject.should_receive(:git_revision).with(subject.repo) {nil}
-      subject.should_receive(:git_named_rev).with(nil) {''}
-      subject.revision.should == ''
+      expect(subject).to receive(:git_revision).with(subject.repo) {nil}
+      expect(subject).to receive(:git_named_rev).with(nil) {''}
+      expect(subject.revision).to eq ''
     end
   end
   
   describe "#installed_addons" do
     it "returns the list of installed addons" do
       with_app(subject, 'name' => subject.app) do |app_data|
-        subject.installed_addons.map{|a|a['name']}.should include *%w[shared-database:5mb]
+        expect(subject.installed_addons.map{|a|a['name']}).to include *%w[shared-database:5mb]
       end
     end
   end
@@ -271,15 +271,15 @@ describe HerokuSan::Stage do
 
     it "installs the addons" do
       with_app(subject, 'name' => subject.app) do |app_data| 
-        subject.install_addons.map{|a| a['name']}.should include *%w[custom_domains:basic ssl:piggyback]
-        subject.installed_addons.map{|a|a['name']}.should =~ subject.install_addons.map{|a| a['name']}
+        expect(subject.install_addons.map{|a| a['name']}).to include *%w[custom_domains:basic ssl:piggyback]
+        expect(subject.installed_addons.map{|a|a['name']}).to match subject.install_addons.map{|a| a['name']}
       end
     end
 
     it "only installs missing addons" do
       subject = Factory::Stage.build('production', {"app" => "awesomeapp", "stack" => "bamboo-ree-1.8.7", "addons" => %w[shared-database:5mb custom_domains:basic ssl:piggyback]})
       with_app(subject, 'name' => subject.app) do |app_data| 
-        subject.install_addons.map{|a| a['name']}.should include *%w[shared-database:5mb custom_domains:basic ssl:piggyback]
+        expect(subject.install_addons.map{|a| a['name']}).to include *%w[shared-database:5mb custom_domains:basic ssl:piggyback]
       end
     end
   end

metadata

@@ -1,8 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: heroku_san
 version: !ruby/object:Gem::Version
-  version: 4.3.2
-  prerelease: 
+  version: 4.4.0
 platform: ruby
 authors:
 - Elijah Miller
@@ -12,54 +11,48 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-10-28 00:00:00.000000000 Z
+date: 2016-03-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: heroku-api
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 0.1.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 0.1.2
 - !ruby/object:Gem::Dependency
   name: json
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 description: Manage multiple Heroku instances/apps for a single Rails app using Rake
@@ -69,10 +62,10 @@ extensions: []
 extra_rdoc_files:
 - README.md
 files:
-- .gitignore
-- .ruby-gemset
-- .ruby-version
-- .travis.yml
+- ".gitignore"
+- ".ruby-gemset"
+- ".ruby-version"
+- ".travis.yml"
 - CHANGELOG.md
 - Gemfile
 - Guardfile
@@ -130,32 +123,28 @@ files:
 homepage: http://github.com/fastestforward/heroku_san
 licenses:
 - MIT
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: -1867339558335233432
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.23
+rubygems_version: 2.4.5.1
 signing_key: 
-specification_version: 3
-summary: ! 'A bunch of useful Rake tasks for managing your Heroku apps. NOTE: The
-  Heroku Toolbelt must be installed to use this gem. https://toolbelt.heroku.com/'
+specification_version: 4
+summary: 'A bunch of useful Rake tasks for managing your Heroku apps. NOTE: The Heroku
+  Toolbelt must be installed to use this gem. https://toolbelt.heroku.com/'
 test_files:
 - features/config.feature
 - features/extended-config.feature