pebblebed 0.3.7 → 0.3.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7e4e34a7978eddde52fa0208e765e5ba26e61733
-  data.tar.gz: 3b85e3ffc4ddab4b27276eb268b8bb525dbf31ce
+  metadata.gz: 45691ca27096676c8395d306b07f6df6e91c4809
+  data.tar.gz: 2db3172af3d0db352483ccc3ff19f1ac99295c62
 SHA512:
-  metadata.gz: b885714ad6c9757195293c731df6e9752f9625a52d1a1afc0329369f0743910d6c5a2c9c377138159c58170907c7d62949448b61984438a0c79c3ffdf5696e2a
-  data.tar.gz: e5d298afb68659ac1e3baf0aa37bcef2df999e46a635b70a8262db24113901790b932bb9a0f44e2729cefaf799142e4efe7d01c9d60869525b070b0e32dcb6a8
+  metadata.gz: d895b88598b93db048cf27460e8d718678cf8314f18dfc53faa8e1f5b92faf3025a6ab2fe0bea15c502d1da6bdb1d0bdb5d85e1ee755e2c071fded6c6153557b
+  data.tar.gz: e98b26afac3664573ee9f8f825192d0e8389cd28804a958dbfd3635498b8df8a77e6cb4d8f93a36c6a7836c3afc10ddf50d18e6f979c99d08142a842c95a4f89

data/lib/pebblebed/config.rb

@@ -94,8 +94,9 @@ module Pebblebed
       [:base_uri, :base_url].each do |key|
         return url_opts[key] if url_opts[key]
       end
-      return "http://#{url_opts[:host]}" if url_opts[:host]
-      base_uri || "http://#{host}"
+      scheme = url_opts[:scheme] || 'http'
+      return "#{scheme}://#{url_opts[:host]}" if url_opts[:host]
+      base_uri || "#{scheme}://#{host}"
     end
   end
 end

data/lib/pebblebed/sinatra.rb

@@ -33,7 +33,12 @@ module Sinatra
       alias :checkpoint_session :current_session
 
       def pebbles
-        @pebbles ||= ::Pebblebed::Connector.new(checkpoint_session, :host => ::Pebblebed.host || request.host)
+        return @pebbles if @pebbles
+        connector_options = {
+          :host => ::Pebblebed.host || request.host,
+          :scheme => request.scheme
+        }
+        @pebbles = ::Pebblebed::Connector.new(checkpoint_session, connector_options)
       end
 
       def current_identity_data

data/lib/pebblebed/version.rb

@@ -1,3 +1,3 @@
 module Pebblebed
-  VERSION = "0.3.7"
+  VERSION = "0.3.8"
 end

data/spec/config_spec.rb

@@ -11,20 +11,20 @@ describe Pebblebed do
       service :checkpoint
     end
 
-    Pebblebed.host.should eq "example.org"
-    Pebblebed.memcached.should eq "MemcachedClient"
-    Pebblebed.session_cookie.should eq "my.session"
-    Pebblebed::Connector.instance_methods.should include :checkpoint
+    expect(Pebblebed.host).to eq "example.org"
+    expect(Pebblebed.memcached).to eq "MemcachedClient"
+    expect(Pebblebed.session_cookie).to eq "my.session"
+    expect(Pebblebed::Connector.instance_methods).to include :checkpoint
   end
 
   it "raises an error when memcached is used but not configured" do
     Pebblebed.memcached = nil
-    -> {Pebblebed.memcached}.should raise_error RuntimeError
+    expect {Pebblebed.memcached}.to raise_error RuntimeError
   end
 
   it "has a default name of 'checkpoint.session' for the session cookie" do
     Pebblebed.session_cookie = nil
-    Pebblebed.session_cookie.should eq "checkpoint.session"
+    expect(Pebblebed.session_cookie).to eq "checkpoint.session"
   end
 
   it "can calculate the root uri of any pebble" do
@@ -33,9 +33,9 @@ describe Pebblebed do
       service :foobar, :version => 2
     end
     Pebblebed.host = "example.org"
-    Pebblebed.root_url_for(:checkpoint).to_s.should eq "http://example.org/api/checkpoint/v1/"
-    Pebblebed.root_url_for(:checkpoint, :host => 'checkpoint.dev').to_s.should eq "http://checkpoint.dev/api/checkpoint/v1/"
-    Pebblebed.root_url_for(:foobar).to_s.should eq "http://example.org/api/foobar/v2/"
+    expect(Pebblebed.root_url_for(:checkpoint).to_s).to eq "http://example.org/api/checkpoint/v1/"
+    expect(Pebblebed.root_url_for(:checkpoint, :host => 'checkpoint.dev').to_s).to eq "http://checkpoint.dev/api/checkpoint/v1/"
+    expect(Pebblebed.root_url_for(:foobar).to_s).to eq "http://example.org/api/foobar/v2/"
   end
 
   it "allows the path of a pebble to be overridden" do
@@ -44,9 +44,9 @@ describe Pebblebed do
       service :foobar, :version => 2
     end
     Pebblebed.host = "example.org"
-    Pebblebed.root_url_for(:checkpoint).to_s.should eq "http://example.org/my_api/my_checkpoint/v1/"
-    Pebblebed.root_url_for(:checkpoint, :host => 'checkpoint.dev').to_s.should eq "http://checkpoint.dev/my_api/my_checkpoint/v1/"
-    Pebblebed.root_url_for(:foobar).to_s.should eq "http://example.org/api/foobar/v2/"
+    expect(Pebblebed.root_url_for(:checkpoint).to_s).to eq "http://example.org/my_api/my_checkpoint/v1/"
+    expect(Pebblebed.root_url_for(:checkpoint, :host => 'checkpoint.dev').to_s).to eq "http://checkpoint.dev/my_api/my_checkpoint/v1/"
+    expect(Pebblebed.root_url_for(:foobar).to_s).to eq "http://example.org/api/foobar/v2/"
   end
 
   it "allows the host of a pebble to be overridden" do
@@ -54,8 +54,8 @@ describe Pebblebed do
       service :checkpoint, host: 'example.net'
     end
     Pebblebed.host = "example.org"
-    Pebblebed.root_url_for(:checkpoint).to_s.should eq "http://example.net/api/checkpoint/v1/"
-    Pebblebed.root_url_for(:checkpoint, :host => 'checkpoint.dev').to_s.should eq "http://checkpoint.dev/api/checkpoint/v1/"
+    expect(Pebblebed.root_url_for(:checkpoint).to_s).to eq "http://example.net/api/checkpoint/v1/"
+    expect(Pebblebed.root_url_for(:checkpoint, :host => 'checkpoint.dev').to_s).to eq "http://checkpoint.dev/api/checkpoint/v1/"
   end
 
   it "works with pebbles that are exposed via https" do
@@ -64,9 +64,9 @@ describe Pebblebed do
       service :foobar, :version => 2
     end
     Pebblebed.base_url = "https://example.org"
-    Pebblebed.root_url_for(:checkpoint).to_s.should eq "https://example.org/api/checkpoint/v1/"
-    Pebblebed.root_url_for(:checkpoint, :base_uri => 'https://checkpoint.dev').to_s.should eq "https://checkpoint.dev/api/checkpoint/v1/"
-    Pebblebed.root_url_for(:foobar).to_s.should eq "https://example.org/api/foobar/v2/"
+    expect(Pebblebed.root_url_for(:checkpoint).to_s).to eq "https://example.org/api/checkpoint/v1/"
+    expect(Pebblebed.root_url_for(:checkpoint, :base_uri => 'https://checkpoint.dev').to_s).to eq "https://checkpoint.dev/api/checkpoint/v1/"
+    expect(Pebblebed.root_url_for(:foobar).to_s).to eq "https://example.org/api/foobar/v2/"
   end
 
   it "allows passed in parameters to take precedence" do
@@ -75,15 +75,15 @@ describe Pebblebed do
       service :foobar, :version => 2
     end
     Pebblebed.base_url = "https://example.org"
-    Pebblebed.root_url_for(:checkpoint, :host => 'checkpoint.dev').to_s.should eq "http://checkpoint.dev/api/checkpoint/v1/"
+    expect(Pebblebed.root_url_for(:checkpoint, :host => 'checkpoint.dev').to_s).to eq "http://checkpoint.dev/api/checkpoint/v1/"
   end
 
   it "raises an error if :host and :base_uri are both specified as parameters" do
     Pebblebed.config do
       service :checkpoint
     end
-    -> {Pebblebed.root_url_for(:checkpoint, :base_uri => 'https://checkpoint.dev', :host => 'checkpoint.dev')}.should raise_error RuntimeError
-    -> {Pebblebed.root_url_for(:checkpoint, :base_url => 'https://checkpoint.dev', :host => 'checkpoint.dev')}.should raise_error RuntimeError
+    expect {Pebblebed.root_url_for(:checkpoint, :base_uri => 'https://checkpoint.dev', :host => 'checkpoint.dev')}.to raise_error RuntimeError
+    expect {Pebblebed.root_url_for(:checkpoint, :base_url => 'https://checkpoint.dev', :host => 'checkpoint.dev')}.to raise_error RuntimeError
   end
 
   it "request_uri takes precedence over host" do
@@ -93,7 +93,7 @@ describe Pebblebed do
       service :foobar, :version => 2
     end
     Pebblebed.base_url = "https://example.org"
-    Pebblebed.root_url_for(:checkpoint).to_s.should eq "https://example.org/api/checkpoint/v1/"
-    Pebblebed.root_url_for(:checkpoint, :base_uri => 'https://checkpoint.dev').to_s.should eq "https://checkpoint.dev/api/checkpoint/v1/"
+    expect(Pebblebed.root_url_for(:checkpoint).to_s).to eq "https://example.org/api/checkpoint/v1/"
+    expect(Pebblebed.root_url_for(:checkpoint, :base_uri => 'https://checkpoint.dev').to_s).to eq "https://checkpoint.dev/api/checkpoint/v1/"
   end
 end

data/spec/connector_spec.rb

@@ -6,24 +6,57 @@ require 'pebblebed/clients/generic_client'
 require 'pebblebed/clients/quorum_client'
 
 describe "Pebblebed::Connector" do
+
+  Pebblebed.config do
+    service :foobar
+  end
+
   it "can configure clients for any service" do
     connector = Pebblebed::Connector.new("session_key")
     client = connector['foobar']
-    client.class.name.should eq "Pebblebed::GenericClient"
-    client.instance_variable_get(:@session_key).should eq "session_key"
-    client.instance_variable_get(:@root_url).to_s.should =~ /api\/foobar/
+    expect(client.class.name).to eq "Pebblebed::GenericClient"
+    expect(client.instance_variable_get(:@session_key)).to eq "session_key"
+    expect(client.instance_variable_get(:@root_url).to_s).to match(/api\/foobar/)
   end
 
   it "caches any given client" do
     connector = Pebblebed::Connector.new("session_key")
-    connector['foobar'].should eq connector['foobar']
+    expect(connector['foobar']).to eq connector['foobar']
   end
 
   it "has key getter and setter" do
     connector = Pebblebed::Connector.new("session_key")
-    connector.key.should == "session_key"
+    expect(connector.key).to eq("session_key")
     connector.key = "another_key"
-    connector.key.should == "another_key"
+    expect(connector.key).to eq("another_key")
+  end
+
+  context 'scheme' do
+
+    Pebblebed.config do
+      service :barbaz
+    end
+
+    it 'works for http' do
+      connector_options = {
+        :host => 'example.org',
+        :scheme => 'http'
+      }
+      connector = ::Pebblebed::Connector.new('session_key', connector_options)
+      client = connector['barbaz']
+      expect(client.instance_variable_get(:@root_url).to_s).to eq 'http://example.org/api/barbaz/v1/'
+    end
+
+    it 'works for https' do
+      connector_options = {
+        :host => 'example.org',
+        :scheme => 'https'
+      }
+      connector = ::Pebblebed::Connector.new('session_key', connector_options)
+      client = connector['barbaz']
+      expect(client.instance_variable_get(:@root_url).to_s).to eq 'https://example.org/api/barbaz/v1/'
+    end
+
   end
 
 end

data/spec/generic_client_spec.rb

@@ -1,4 +1,5 @@
 require 'spec_helper'
+require 'pebblebed/config'
 require 'pebblebed/clients/abstract_client'
 require 'pebblebed/clients/generic_client'
 
@@ -8,39 +9,44 @@ module Pebblebed
 end
 
 describe Pebblebed::GenericClient do
+
+  Pebblebed.config do
+    memcached "MemcachedClient"
+  end
+
   it "always forwards the session key" do
     client = Pebblebed::GenericClient.new("session_key", "http://example.org/")
-    client.service_params({})['session'].should eq "session_key"
+    expect(client.service_params({})['session']).to eq "session_key"
   end
 
   it "always converts urls to URI-objects" do
     client = Pebblebed::GenericClient.new("session_key", "http://example.org/")
-    client.instance_variable_get(:@root_url).class.name.should eq ("URI::HTTP")
+    expect(client.instance_variable_get(:@root_url).class.name).to eq ("URI::HTTP")
   end
 
   it "knows how to generate a service specific url" do
     client = Pebblebed::GenericClient.new("session_key", "http://example.org/")
-    client.service_url("/test").to_s.should eq "http://example.org/test"
-    client.service_url("").to_s.should eq "http://example.org"
-    client.service_url("/test", :foo => 'bar').to_s.should eq "http://example.org/test?foo=bar"
+    expect(client.service_url("/test").to_s).to eq "http://example.org/test"
+    expect(client.service_url("").to_s).to eq "http://example.org"
+    expect(client.service_url("/test", :foo => 'bar').to_s).to eq "http://example.org/test?foo=bar"
   end
 
   it "wraps JSON-results in a deep struct" do
     curl_result = DeepStruct.wrap({status:200, body:'{"hello":"world"}'})
-    Pebblebed::Http.stub(:get).and_return(curl_result)
+    allow(Pebblebed::Http).to receive(:get).and_return(curl_result)
     client = Pebblebed::GenericClient.new("session_key", "http://example.org/")
     result = client.get "/"
-    result.class.name.should eq "DeepStruct::HashWrapper"
-    result.hello.should eq "world"
+    expect(result.class.name).to eq "DeepStruct::HashWrapper"
+    expect(result.hello).to eq "world"
   end
 
   it "does not wrap non-json results" do
     curl_result = DeepStruct.wrap({status:200, body:'Ok'})
-    Pebblebed::Http.stub(:get).and_return(curl_result)
+    allow(Pebblebed::Http).to receive(:get).and_return(curl_result)
     client = Pebblebed::GenericClient.new("session_key", "http://example.org/")
     result = client.get "/"
-    result.class.name.should eq "String"
-    result.should eq "Ok"
+    expect(result.class.name).to eq "String"
+    expect(result).to eq "Ok"
   end
 
 end

data/spec/http_spec.rb

@@ -3,10 +3,15 @@
 require 'spec_helper'
 require 'yajl/json_gem'
 require 'pebblebed/http'
+require 'pebblebed/config'
 require 'deepstruct'
 
 describe Pebblebed::Http do
 
+  Pebblebed.config do
+    memcached "MemcachedClient"
+  end
+
   def mock_pebble
     @mp ||= MockPebble.new
   end
@@ -27,43 +32,43 @@ describe Pebblebed::Http do
   end
 
   it "knows how to pack params into a http query string" do
-    Pebblebed::Http.send(:url_with_params, URI("/dingo/"), {a:1}).should eq "/dingo/?a=1"
+    expect(Pebblebed::Http.send(:url_with_params, URI("/dingo/"), {a:1})).to eq "/dingo/?a=1"
   end
 
   it "knows how to combine url and parmas with results of pathbuilder" do
     url, params = Pebblebed::Http.send(:url_and_params_from_args, URI("http://example.org/api"), {a:1}) do
       foo.bar(:b => 2)
     end
-    params.should eq(:a => 1, :b => 2)
-    url.to_s.should eq "http://example.org/api/foo/bar"
+    expect(params).to eq(:a => 1, :b => 2)
+    expect(url.to_s).to eq "http://example.org/api/foo/bar"
   end
 
   it "handles urls as strings" do
     url, params = Pebblebed::Http.send(:url_and_params_from_args, "http://example.org/api", {a:1}) do
       foo.bar(:b => 2)
     end
-    params.should eq(:a => 1, :b => 2)
-    url.to_s.should eq "http://example.org/api/foo/bar"
+    expect(params).to eq(:a => 1, :b => 2)
+    expect(url.to_s).to eq "http://example.org/api/foo/bar"
   end
 
   it "raises an HttpNotFoundError if there is a 404 error" do
-    -> { Pebblebed::Http.send(:handle_http_errors, DeepStruct.wrap(status: 404, url: "/foobar", body: "Not found")) }.should raise_error Pebblebed::HttpNotFoundError
+    expect { Pebblebed::Http.send(:handle_http_errors, DeepStruct.wrap(status: 404, url: "/foobar", body: "Not found")) }.to raise_error Pebblebed::HttpNotFoundError
   end
 
   it "includes the url of the failed resource in the error message" do
-    -> { Pebblebed::Http.send(:handle_http_errors, DeepStruct.wrap(status: 404, url: "/nosuchresource", body: "Not found")) }.should raise_error Pebblebed::HttpNotFoundError, /\/nosuchresource/
+    expect { Pebblebed::Http.send(:handle_http_errors, DeepStruct.wrap(status: 404, url: "/nosuchresource", body: "Not found")) }.to raise_error Pebblebed::HttpNotFoundError, /\/nosuchresource/
   end
 
   it "raises an HttpError if there is any other http-error" do
-    -> { Pebblebed::Http.send(:handle_http_errors, DeepStruct.wrap(status: 400, url: "/foobar", body: "Oh noes")) }.should raise_error Pebblebed::HttpError
+    expect { Pebblebed::Http.send(:handle_http_errors, DeepStruct.wrap(status: 400, url: "/foobar", body: "Oh noes")) }.to raise_error Pebblebed::HttpError
   end
 
   it "encodes posts and puts as json if the params is a hash" do
     ['post', 'put'].each do |method|
       response = Pebblebed::Http.send(method.to_sym, pebble_url, {hello:'world'})
       result = JSON.parse(response.body)
-      result["CONTENT_TYPE"].should =~ %r{^application/json\b}i
-      JSON.parse(result["BODY"])['hello'].should eq 'world'
+      expect(result["CONTENT_TYPE"]).to match(%r{^application/json\b}i)
+      expect(JSON.parse(result["BODY"])['hello']).to eq 'world'
     end
   end
 
@@ -71,15 +76,15 @@ describe Pebblebed::Http do
     ['post', 'put'].each do |method|
       response = Pebblebed::Http.send(method.to_sym, pebble_url, "Hello world")
       result = JSON.parse(response.body)
-      result["CONTENT_TYPE"].should =~ %r{^text/plain\b}i
-      result["BODY"].should eq "Hello world"
+      expect(result["CONTENT_TYPE"]).to match(%r{^text/plain\b}i)
+      expect(result["BODY"]).to eq "Hello world"
     end
   end
 
   it "encodes gets as url params" do
     response = Pebblebed::Http.get(pebble_url, {hello: 'world'})
     result = JSON.parse(response.body)
-    result["QUERY_STRING"].should eq "hello=world"
+    expect(result["QUERY_STRING"]).to eq "hello=world"
   end
 
 end

data/spec/labels_spec.rb

@@ -5,29 +5,57 @@ describe Pebblebed::Labels do
 
   describe "default labels" do
     subject { Pebblebed::Labels.new('a.b.c') }
-    its(:expanded) {  should eq('label_0' => "a", 'label_1' => "b", 'label_2' => "c") }
-    its(:wildcard?) { should == false }
+
+    describe '#expanded' do
+      subject { super().expanded }
+      it {  is_expected.to eq('label_0' => "a", 'label_1' => "b", 'label_2' => "c") }
+    end
+
+    describe '#wildcard?' do
+      subject { super().wildcard? }
+      it { is_expected.to eq(false) }
+    end
   end
 
   describe "with a stop label" do
     subject { Pebblebed::Labels.new('a.b.c', :stop => nil) }
-    its(:expanded) {  should eq('label_0' => "a", 'label_1' => "b", 'label_2' => "c", 'label_3' => nil) }
+
+    describe '#expanded' do
+      subject { super().expanded }
+      it {  is_expected.to eq('label_0' => "a", 'label_1' => "b", 'label_2' => "c", 'label_3' => nil) }
+    end
   end
 
   describe "customized labels" do
     subject { Pebblebed::Labels.new('p.r.q', :prefix => 'dot', :suffix => '', :stop => '<END>') }
-    its(:expanded) { should eq('dot_0_' => 'p', 'dot_1_' => 'r', 'dot_2_' => 'q', 'dot_3_' => '<END>') }
+
+    describe '#expanded' do
+      subject { super().expanded }
+      it { is_expected.to eq('dot_0_' => 'p', 'dot_1_' => 'r', 'dot_2_' => 'q', 'dot_3_' => '<END>') }
+    end
   end
 
   describe "next label" do
     subject { Pebblebed::Labels.new('a.b.c', :prefix => 'thing') }
-    its(:next) { should eq('thing_3') }
+
+    describe '#next' do
+      subject { super().next }
+      it { is_expected.to eq('thing_3') }
+    end
   end
 
   describe "with wildcard *" do
     subject { Pebblebed::Labels.new('a.b.c.*') }
-    its(:expanded) { should eq('label_0' => "a", 'label_1' => "b", 'label_2' => "c") }
-    its(:wildcard?) { should == true }
+
+    describe '#expanded' do
+      subject { super().expanded }
+      it { is_expected.to eq('label_0' => "a", 'label_1' => "b", 'label_2' => "c") }
+    end
+
+    describe '#wildcard?' do
+      subject { super().wildcard? }
+      it { is_expected.to eq(true) }
+    end
   end
 
 end

data/spec/river_spec.rb

@@ -1,22 +1,27 @@
 require 'spec_helper'
 require 'pebblebed/river'
 require 'pebblebed/uid'
+require 'pebblebed/config'
 
 describe Pebblebed::River do
 
   describe "routing keys" do
 
+    Pebblebed.config do
+      memcached 'MemcachedClient'
+    end
+
     specify do
       options = {:event => 'created', :uid => 'post.awesome.event:feeds.bagera.whatevs$123'}
-      Pebblebed::River.route(options).should eq('created._.post.awesome.event._.feeds.bagera.whatevs')
+      expect(Pebblebed::River.route(options)).to eq('created._.post.awesome.event._.feeds.bagera.whatevs')
     end
 
     specify "event is required" do
-      ->{ Pebblebed::River.route(:uid => 'whatevs') }.should raise_error ArgumentError
+      expect{ Pebblebed::River.route(:uid => 'whatevs') }.to raise_error ArgumentError
     end
 
     specify "uid is required" do
-      ->{ Pebblebed::River.route(:event => 'whatevs') }.should raise_error ArgumentError
+      expect{ Pebblebed::River.route(:event => 'whatevs') }.to raise_error ArgumentError
     end
 
   end

data/spec/river_subscription_spec.rb

@@ -1,30 +1,35 @@
 require 'spec_helper'
+require 'pebblebed/config'
 require 'pebblebed/river/subscription'
 
 describe Pebblebed::River::Subscription do
 
+  Pebblebed.config do
+    memcached 'MemcachedClient'
+  end
+
   Subscription = Pebblebed::River::Subscription
 
   specify 'simple, direct match' do
     options = {:event => 'create', :klass => 'post.event', :path => 'feed.bagera'}
     subscription = Subscription.new(options)
-    subscription.queries.should eq(['create._.post.event._.feed.bagera'])
+    expect(subscription.queries).to eq(['create._.post.event._.feed.bagera'])
   end
 
   specify 'simple wildcard match' do
     options = {:event => '*.create', :klass => 'post.*', :path => '*.bagera.*'}
-    Subscription.new(options).queries.should eq(['*.create._.post.*._.*.bagera.*'])
+    expect(Subscription.new(options).queries).to eq(['*.create._.post.*._.*.bagera.*'])
   end
 
   describe "anything matchers" do
 
     specify 'match anything (duh)' do
       options = {:event => '**', :klass => '**', :path => '**'}
-      Subscription.new(options).queries.should eq(['#._.#._.#'])
+      expect(Subscription.new(options).queries).to eq(['#._.#._.#'])
     end
 
     specify 'match anything if not specified' do
-      Subscription.new.queries.should eq(['#._.#._.#'])
+      expect(Subscription.new.queries).to eq(['#._.#._.#'])
     end
 
   end
@@ -32,18 +37,18 @@ describe Pebblebed::River::Subscription do
   it 'handles "or" queries' do
     options = {:event => 'create|delete', :klass => 'post', :path => 'bagera|bandwagon'}
     expected = ['create._.post._.bagera', 'delete._.post._.bagera', 'create._.post._.bandwagon', 'delete._.post._.bandwagon'].sort
-    Subscription.new(options).queries.sort.should eq(expected)
+    expect(Subscription.new(options).queries.sort).to eq(expected)
   end
 
   describe "optional paths" do
-    it { Subscription.new.pathify('a.b').should eq(['a.b']) }
-    it { Subscription.new.pathify('a.^b.c').should eq(%w(a a.b a.b.c)) }
+    it { expect(Subscription.new.pathify('a.b')).to eq(['a.b']) }
+    it { expect(Subscription.new.pathify('a.^b.c')).to eq(%w(a a.b a.b.c)) }
   end
 
   it "handles optional queries" do
     options = {:event => 'create', :klass => 'post', :path => 'feeds.bagera.^fb.concerts'}
     expected = ['create._.post._.feeds.bagera', 'create._.post._.feeds.bagera.fb', 'create._.post._.feeds.bagera.fb.concerts'].sort
-    Subscription.new(options).queries.sort.should eq(expected)
+    expect(Subscription.new(options).queries.sort).to eq(expected)
   end
 
   it "combines all kinds of weird stuff" do
@@ -56,7 +61,7 @@ describe Pebblebed::River::Subscription do
       'create._.post._.x.y',
       'create._.post._.x.y.z',
     ].sort
-    Subscription.new(options).queries.sort.should eq(expected)
+    expect(Subscription.new(options).queries.sort).to eq(expected)
   end
 
 end

data/spec/security/access_data_spec.rb

@@ -11,15 +11,15 @@ describe Pebblebed::Security::AccessData do
   end
 
   it "can calculate a pristine path" do
-    Pebblebed::Security::AccessData.pristine_path("a.b.c|d").should eq "a.b"
-    Pebblebed::Security::AccessData.pristine_path("a.b").should eq "a.b"
+    expect(Pebblebed::Security::AccessData.pristine_path("a.b.c|d")).to eq "a.b"
+    expect(Pebblebed::Security::AccessData.pristine_path("a.b")).to eq "a.b"
   end
 
   it "can calculate relevant paths" do
-    access_data.relevant_subtrees('a.b').sort.should eq ['a.b', 'a.b.c.d.e']
-    access_data.relevant_subtrees('a.b.c').sort.should eq ['a.b', 'a.b.c.d.e']
-    access_data.relevant_subtrees('a.c.e').sort.should eq ['a.c.e.f']
-    access_data.relevant_subtrees('a.*').sort.should eq ['a.b', 'a.b.c.d.e', 'a.c.d', 'a.c.e.f']
+    expect(access_data.relevant_subtrees('a.b').sort).to eq ['a.b', 'a.b.c.d.e']
+    expect(access_data.relevant_subtrees('a.b.c').sort).to eq ['a.b', 'a.b.c.d.e']
+    expect(access_data.relevant_subtrees('a.c.e').sort).to eq ['a.c.e.f']
+    expect(access_data.relevant_subtrees('a.*').sort).to eq ['a.b', 'a.b.c.d.e', 'a.c.d', 'a.c.e.f']
   end
 
   it "can parse a checkpoint record" do
@@ -34,7 +34,7 @@ describe Pebblebed::Security::AccessData do
       ]
     }
     ad = Pebblebed::Security::AccessData.new(record)
-    ad.subtrees.sort.should eq ['a.b.c', 'a.c.d.c']
-    ad.group_ids.sort.should eq [1,2]
+    expect(ad.subtrees.sort).to eq ['a.b.c', 'a.c.d.c']
+    expect(ad.group_ids.sort).to eq [1,2]
   end
 end

data/spec/security/client_spec.rb

@@ -22,8 +22,8 @@ describe Pebblebed::Security::Client do
   end
 
   it "can fetch access_data" do
-    client.stub(:fetch_membership_data_for).and_return(sample_memberships_record)
+    allow(client).to receive(:fetch_membership_data_for).and_return(sample_memberships_record)
     ad = client.access_data_for(1)
-    ad.subtrees.sort.should eq ['a.b.c', 'a.c.d.c']
+    expect(ad.subtrees.sort).to eq ['a.b.c', 'a.c.d.c']
   end
 end

data/spec/security/listener_spec.rb

@@ -21,6 +21,6 @@ describe Pebblebed::Security::Listener do
       }
     }.to_json}
     listener.send(:consider, message)
-    the_attrs[:id].should eq 10
+    expect(the_attrs[:id]).to eq 10
   end
 end

data/spec/security/role_shema_spec.rb

@@ -64,17 +64,17 @@ describe Pebblebed::Security::RoleSchema do
     }
 
     it "has connector and identity attributes" do
-      schema.connector.should eq connector
-      schema.identity.should eq guest
+      expect(schema.connector).to eq connector
+      expect(schema.identity).to eq guest
     end
 
     it "has the correct roles defined" do
-      CustomRoleSchema.roles.should ==  [{:capabilities=>[], :requirements=>[], :name=>:guest, :role_rank=>0, :upgrades=>{:kudo=>[:logged_in], :comment=>[:logged_in, :verified_mobile]}}, {:capabilities=>[:kudo], :requirements=>[:logged_in], :name=>:identified, :role_rank=>1}, {:capabilities=>[:comment], :requirements=>[:logged_in, :verified_mobile], :name=>:contributor, :role_rank=>2}]
+      expect(CustomRoleSchema.roles).to eq([{:capabilities=>[], :requirements=>[], :name=>:guest, :role_rank=>0, :upgrades=>{:kudo=>[:logged_in], :comment=>[:logged_in, :verified_mobile]}}, {:capabilities=>[:kudo], :requirements=>[:logged_in], :name=>:identified, :role_rank=>1}, {:capabilities=>[:comment], :requirements=>[:logged_in, :verified_mobile], :name=>:contributor, :role_rank=>2}])
     end
 
     it "has an answer to requirements for a role" do
-      CustomRoleSchema.requirements_for_role(:identified).should == [:logged_in]
-      CustomRoleSchema.requirements_for_role(:contributor).should == [:logged_in, :verified_mobile]
+      expect(CustomRoleSchema.requirements_for_role(:identified)).to eq([:logged_in])
+      expect(CustomRoleSchema.requirements_for_role(:contributor)).to eq([:logged_in, :verified_mobile])
     end
 
     it "gives a exception when the role is not found" do
@@ -92,7 +92,7 @@ describe Pebblebed::Security::RoleSchema do
     }
 
     it "returns the guest role" do
-      schema.role.should == {:current=>:guest, :capabilities=>[], :upgrades=>{:kudo=>[:logged_in], :comment=>[:logged_in, :verified_mobile]}}
+      expect(schema.role).to eq({:current=>:guest, :capabilities=>[], :upgrades=>{:kudo=>[:logged_in], :comment=>[:logged_in, :verified_mobile]}})
     end
 
   end
@@ -106,7 +106,7 @@ describe Pebblebed::Security::RoleSchema do
         }
 
         it "returns the idenitified role with an upgrade for :verified_mobile only" do
-          schema.role.should == {:current=>:identified, :capabilities=>[:kudo], :upgrades=>{:comment=>[:verified_mobile]}}
+          expect(schema.role).to eq({:current=>:identified, :capabilities=>[:kudo], :upgrades=>{:comment=>[:verified_mobile]}})
         end
 
       end
@@ -118,7 +118,7 @@ describe Pebblebed::Security::RoleSchema do
         }
 
         it "returns the contributor role" do
-          schema.role.should ==  {:current=>:contributor, :capabilities=>[:kudo, :comment], :upgrades=>{}}
+          expect(schema.role).to eq({:current=>:contributor, :capabilities=>[:kudo, :comment], :upgrades=>{}})
         end
 
       end

data/spec/sinatra_spec.rb

@@ -70,22 +70,22 @@ describe Sinatra::Pebblebed do
 
     specify "can see public endpoint" do
       get '/public'
-      last_response.body.should == 'You are a guest here'
+      expect(last_response.body).to eq('You are a guest here')
     end
 
     it "can assign a provisional identity" do
       get '/public', :provisional => 'yes'
-      last_response.status.should == 302
+      expect(last_response.status).to eq(302)
     end
 
     specify "cannot see private endpoints" do
       get '/private'
-      last_response.status.should == 403
+      expect(last_response.status).to eq(403)
     end
 
     it "cannot see root endpoints" do
       get '/root'
-      last_response.status.should == 403
+      expect(last_response.status).to eq(403)
     end
   end
 
@@ -94,17 +94,17 @@ describe Sinatra::Pebblebed do
 
     specify "can see public endpoint" do
       get '/public'
-      last_response.body.should == 'You are a guest here'
+      expect(last_response.body).to eq('You are a guest here')
     end
 
     specify "can see private endpoints" do
       get '/private'
-      last_response.body.should == 'You are logged in'
+      expect(last_response.body).to eq('You are logged in')
     end
 
     it "cannot see root endpoints" do
       get '/root'
-      last_response.status.should == 403
+      expect(last_response.status).to eq(403)
     end
   end
 
@@ -113,17 +113,17 @@ describe Sinatra::Pebblebed do
 
     specify "can see public endpoint" do
       get '/public'
-      last_response.body.should == 'You are a guest here'
+      expect(last_response.body).to eq('You are a guest here')
     end
 
     specify "can see private endpoints" do
       get '/private'
-      last_response.body.should == 'You are logged in'
+      expect(last_response.body).to eq('You are logged in')
     end
 
     it "cannot see root endpoints" do
       get '/root'
-      last_response.body.should == 'You are most powerful'
+      expect(last_response.body).to eq('You are most powerful')
     end
   end
 
@@ -136,34 +136,34 @@ describe Sinatra::Pebblebed do
       specify "not allowed" do
         guest!
         get '/group'
-        last_response.status.should == 403
+        expect(last_response.status).to eq(403)
       end
     end
     context "as a god" do
       specify "allowed without policy check" do
         god!(:session => random_session)
         get '/group'
-        last_response.body.should == "You are granted access to this content"
+        expect(last_response.body).to eq("You are granted access to this content")
       end
     end
     context "as user without grants" do
       specify "is disallowed" do
         user!
-        checkpoint.should_receive(:get).with("/identities/me").and_return(DeepStruct.wrap(:identity => {:realm => 'testrealm', :id => 1, :god => false}))
-        checkpoint.should_receive(:get).with("/identities/1/access_to/testrealm.specialgroup.123").and_return(DeepStruct.wrap(:access => {:granted => false}))
+        expect(checkpoint).to receive(:get).with("/identities/me").and_return(DeepStruct.wrap(:identity => {:realm => 'testrealm', :id => 1, :god => false}))
+        expect(checkpoint).to receive(:get).with("/identities/1/access_to/testrealm.specialgroup.123").and_return(DeepStruct.wrap(:access => {:granted => false}))
         Pebblebed::Connector.any_instance.stub(:checkpoint => checkpoint)
         get '/group'
-        last_response.status.should == 403
+        expect(last_response.status).to eq(403)
       end
     end
     context "as user with grants" do
       specify "is allowed" do
         user!
-        checkpoint.should_receive(:get).with("/identities/me").and_return(DeepStruct.wrap(:identity => {:realm => 'testrealm', :id => 1, :god => false}))
-        checkpoint.should_receive(:get).with("/identities/1/access_to/testrealm.specialgroup.123").and_return(DeepStruct.wrap(:access => {:granted => true}))
+        expect(checkpoint).to receive(:get).with("/identities/me").and_return(DeepStruct.wrap(:identity => {:realm => 'testrealm', :id => 1, :god => false}))
+        expect(checkpoint).to receive(:get).with("/identities/1/access_to/testrealm.specialgroup.123").and_return(DeepStruct.wrap(:access => {:granted => true}))
         Pebblebed::Connector.any_instance.stub(:checkpoint => checkpoint)
         get '/group'
-        last_response.body.should == "You are granted access to this content"
+        expect(last_response.body).to eq("You are granted access to this content")
       end
     end
   end
@@ -177,64 +177,64 @@ describe Sinatra::Pebblebed do
       specify "not allowed" do
         guest!
         post '/create/post.foo:testrealm'
-        last_response.status.should == 403
+        expect(last_response.status).to eq(403)
       end
     end
     context "as a god" do
       specify "allowed without callbacks" do
         god!(:session => random_session)
         post '/create/post.foo:testrealm'
-        last_response.body.should == "You are creative"
+        expect(last_response.body).to eq("You are creative")
       end
     end
     context "as user without permissions" do
       specify "is disallowed" do
         user!
-        checkpoint.should_receive(:get).with("/identities/me").and_return(DeepStruct.wrap(:identity => {:realm => 'testrealm', :id => 1, :god => false}))
-        checkpoint.should_receive(:post).with("/callbacks/allowed/create/post.foo:testrealm").and_return(DeepStruct.wrap(:allowed => false, :reason => "You are not worthy!"))
+        expect(checkpoint).to receive(:get).with("/identities/me").and_return(DeepStruct.wrap(:identity => {:realm => 'testrealm', :id => 1, :god => false}))
+        expect(checkpoint).to receive(:post).with("/callbacks/allowed/create/post.foo:testrealm").and_return(DeepStruct.wrap(:allowed => false, :reason => "You are not worthy!"))
         Pebblebed::Connector.any_instance.stub(:checkpoint => checkpoint)
         post '/create/post.foo:testrealm'
-        last_response.status.should == 403
-        last_response.body.should == ":create denied for post.foo:testrealm : You are not worthy!"
+        expect(last_response.status).to eq(403)
+        expect(last_response.body).to eq(":create denied for post.foo:testrealm : You are not worthy!")
       end
     end
     context "as user with permissions" do
       specify "is allowed" do
         user!
-        checkpoint.should_receive(:get).with("/identities/me").and_return(DeepStruct.wrap(:identity => {:realm => 'testrealm', :id => 1, :god => false}))
-        checkpoint.should_receive(:post).with("/callbacks/allowed/create/post.foo:testrealm").and_return(DeepStruct.wrap(:allowed => true))
+        expect(checkpoint).to receive(:get).with("/identities/me").and_return(DeepStruct.wrap(:identity => {:realm => 'testrealm', :id => 1, :god => false}))
+        expect(checkpoint).to receive(:post).with("/callbacks/allowed/create/post.foo:testrealm").and_return(DeepStruct.wrap(:allowed => true))
         Pebblebed::Connector.any_instance.stub(:checkpoint => checkpoint)
         post '/create/post.foo:testrealm'
-        last_response.body.should == "You are creative"
+        expect(last_response.body).to eq("You are creative")
       end
       context "with options[:default] => false" do
         specify "is disallowed" do
           user!
-          checkpoint.should_receive(:get).with("/identities/me").and_return(DeepStruct.wrap(:identity => {:realm => 'testrealm', :id => 1, :god => false}))
-          checkpoint.should_receive(:post).with("/callbacks/allowed/create/post.foo:testrealm").and_return(DeepStruct.wrap(:allowed => "default"))
+          expect(checkpoint).to receive(:get).with("/identities/me").and_return(DeepStruct.wrap(:identity => {:realm => 'testrealm', :id => 1, :god => false}))
+          expect(checkpoint).to receive(:post).with("/callbacks/allowed/create/post.foo:testrealm").and_return(DeepStruct.wrap(:allowed => "default"))
           Pebblebed::Connector.any_instance.stub(:checkpoint => checkpoint)
           post '/create2/post.foo:testrealm'
-          last_response.status.should == 403
+          expect(last_response.status).to eq(403)
         end
       end
       context "with no options given and allowed = default" do
         specify "is disallowed" do
           user!
-          checkpoint.should_receive(:get).with("/identities/me").and_return(DeepStruct.wrap(:identity => {:realm => 'testrealm', :id => 1, :god => false}))
-          checkpoint.should_receive(:post).with("/callbacks/allowed/create/post.foo:testrealm").and_return(DeepStruct.wrap(:allowed => "default"))
+          expect(checkpoint).to receive(:get).with("/identities/me").and_return(DeepStruct.wrap(:identity => {:realm => 'testrealm', :id => 1, :god => false}))
+          expect(checkpoint).to receive(:post).with("/callbacks/allowed/create/post.foo:testrealm").and_return(DeepStruct.wrap(:allowed => "default"))
           Pebblebed::Connector.any_instance.stub(:checkpoint => checkpoint)
           post '/create/post.foo:testrealm'
-          last_response.status.should == 403
+          expect(last_response.status).to eq(403)
         end
       end
       context "with options[:default] => true" do
         specify "is allowed" do
           user!
-          checkpoint.should_receive(:get).with("/identities/me").and_return(DeepStruct.wrap(:identity => {:realm => 'testrealm', :id => 1, :god => false}))
-          checkpoint.should_receive(:post).with("/callbacks/allowed/create/post.foo:testrealm").and_return(DeepStruct.wrap(:allowed => "default"))
+          expect(checkpoint).to receive(:get).with("/identities/me").and_return(DeepStruct.wrap(:identity => {:realm => 'testrealm', :id => 1, :god => false}))
+          expect(checkpoint).to receive(:post).with("/callbacks/allowed/create/post.foo:testrealm").and_return(DeepStruct.wrap(:allowed => "default"))
           Pebblebed::Connector.any_instance.stub(:checkpoint => checkpoint)
           post '/create3/post.foo:testrealm'
-          last_response.body.should == "You are creative"
+          expect(last_response.body).to eq("You are creative")
         end
       end
     end
@@ -247,14 +247,14 @@ describe Sinatra::Pebblebed do
       let(:checkpoint) { Pebblebed::Connector.new.checkpoint }
 
       it "is not turned on by default" do
-        checkpoint.should_receive(:get).twice
+        expect(checkpoint).to receive(:get).twice
         get '/private'
         get '/private'
       end
 
       it "can be turned on" do
         app.set :cache_current_identity, true
-        checkpoint.should_receive(:get).once
+        expect(checkpoint).to receive(:get).once
         get '/private'
         get '/private'
       end
@@ -264,7 +264,7 @@ describe Sinatra::Pebblebed do
 
         it "is disabled" do
           app.set :cache_current_identity, true
-          checkpoint.should_receive(:get).twice
+          expect(checkpoint).to receive(:get).twice
           get '/private'
           get '/private'
         end

data/spec/uid_spec.rb

@@ -6,67 +6,112 @@ describe Pebblebed::Uid do
     context "a full uid" do
       subject { Pebblebed::Uid.new("klass:path$oid") }
 
-      its(:klass) { should eq "klass" }
-      its(:path) { should eq "path" }
-      its(:oid) { should eq "oid" }
-      its(:to_s) { should eq "klass:path$oid" }
+      describe '#klass' do
+        subject { super().klass }
+        it { is_expected.to eq "klass" }
+      end
+
+      describe '#path' do
+        subject { super().path }
+        it { is_expected.to eq "path" }
+      end
+
+      describe '#oid' do
+        subject { super().oid }
+        it { is_expected.to eq "oid" }
+      end
+
+      describe '#to_s' do
+        subject { super().to_s }
+        it { is_expected.to eq "klass:path$oid" }
+      end
     end
 
     context "without oid" do
       subject { Pebblebed::Uid.new("klass:path") }
 
-      its(:klass) { should eq "klass" }
-      its(:path) { should eq "path" }
-      its(:oid) { should be_nil }
-      its(:to_s) { should eq "klass:path" }
+      describe '#klass' do
+        subject { super().klass }
+        it { is_expected.to eq "klass" }
+      end
+
+      describe '#path' do
+        subject { super().path }
+        it { is_expected.to eq "path" }
+      end
+
+      describe '#oid' do
+        subject { super().oid }
+        it { is_expected.to be_nil }
+      end
+
+      describe '#to_s' do
+        subject { super().to_s }
+        it { is_expected.to eq "klass:path" }
+      end
     end
 
     context "without path" do
       subject { Pebblebed::Uid.new("klass:$oid") }
 
-      its(:klass) { should eq "klass" }
-      its(:path) { should be_nil }
-      its(:oid) { should eq "oid" }
-      its(:to_s) { should eq "klass:$oid" }
+      describe '#klass' do
+        subject { super().klass }
+        it { is_expected.to eq "klass" }
+      end
+
+      describe '#path' do
+        subject { super().path }
+        it { is_expected.to be_nil }
+      end
+
+      describe '#oid' do
+        subject { super().oid }
+        it { is_expected.to eq "oid" }
+      end
+
+      describe '#to_s' do
+        subject { super().to_s }
+        it { is_expected.to eq "klass:$oid" }
+      end
     end
   end
 
   it "can be created with a string" do
     uid = Pebblebed::Uid.new "klass:some.path$oid"
-    uid.to_s.should eq "klass:some.path$oid"
+    expect(uid.to_s).to eq "klass:some.path$oid"
   end
 
   it "can be created using parameters" do
     uid = Pebblebed::Uid.new :klass => 'klass', :path => 'some.path', :oid => 'oid'
-    uid.to_s.should eq "klass:some.path$oid"
+    expect(uid.to_s).to eq "klass:some.path$oid"
   end
 
   it "raises an error if parameter is neither string or hash" do
-    lambda {Pebblebed::Uid.new([])}.should raise_exception
+    expect {Pebblebed::Uid.new([])}.to raise_exception
   end
 
   it "raises an exception when you try to create an invalid uid" do
-    -> { Pebblebed::Uid.new("!:$298") }.should raise_error Pebblebed::InvalidUid
+    expect { Pebblebed::Uid.new("!:$298") }.to raise_error Pebblebed::InvalidUid
   end
 
   describe "raises an exception when you modify a uid with an invalid value" do
     let(:uid) { Pebblebed::Uid.new("klass:path$oid") }
-    specify { -> { uid.klass = "!" }.should raise_error Pebblebed::InvalidUid }
-    specify { -> { uid.path = "..." }.should raise_error Pebblebed::InvalidUid }
-    specify { -> { uid.oid = "/" }.should raise_error Pebblebed::InvalidUid }
+    specify { expect { uid.klass = "!" }.to raise_error Pebblebed::InvalidUid }
+    specify { expect { uid.path = "..." }.to raise_error Pebblebed::InvalidUid }
+    specify { expect { uid.oid = "/" }.to raise_error Pebblebed::InvalidUid }
   end
 
   describe "klass" do
     let(:uid) { Pebblebed::Uid.new("klass:path$oid") }
 
     it "allows sub-klasses" do
-      ->{ uid.klass = "sub.sub.class" }.should_not raise_error
+      expect{ uid.klass = "sub.sub.class" }.not_to raise_error
     end
 
     describe "is valid" do
       %w(. - _ 8).each do |nice_character|
         it "with '#{nice_character}'" do
-          ->{ uid.klass = "a#{nice_character}z" }.should_not raise_error
+          expect{ uid.klass = "a#{nice_character}z" }.not_to raise_error
         end
       end
     end
@@ -74,7 +119,7 @@ describe Pebblebed::Uid do
     describe "is invalid" do
       %w(! / : $ % $).each do |funky_character|
         specify "with '#{funky_character}'" do
-          ->{ uid.klass = "a#{funky_character}z" }.should raise_error Pebblebed::InvalidUid
+          expect{ uid.klass = "a#{funky_character}z" }.to raise_error Pebblebed::InvalidUid
         end
       end
     end
@@ -90,107 +135,107 @@ describe Pebblebed::Uid do
       "post:some.path$oid",
     ].each do |oid|
       specify "'#{oid}' is a valid oid if GCI escaped" do
-        Pebblebed::Uid.valid_oid?(CGI.escape(oid)).should be_true
+        expect(Pebblebed::Uid.valid_oid?(CGI.escape(oid))).to be_truthy
       end
     end
 
     specify "'abc/123' is an invalid oid" do
-      Pebblebed::Uid.valid_oid?('abc/123').should be_false
+      expect(Pebblebed::Uid.valid_oid?('abc/123')).to be_falsey
     end
 
     it "can be missing" do
-      Pebblebed::Uid.new('klass:path').oid.should be_nil
+      expect(Pebblebed::Uid.new('klass:path').oid).to be_nil
     end
 
     it "is not valid if it is nil" do
-      Pebblebed::Uid.valid_oid?(nil).should be_false
+      expect(Pebblebed::Uid.valid_oid?(nil)).to be_falsey
     end
   end
 
   it "rejects invalid labels for klass" do
-    Pebblebed::Uid.valid_klass?("abc123").should be_true
-    Pebblebed::Uid.valid_klass?("abc123!").should be_false
-    Pebblebed::Uid.valid_klass?("").should be_false
+    expect(Pebblebed::Uid.valid_klass?("abc123")).to be_truthy
+    expect(Pebblebed::Uid.valid_klass?("abc123!")).to be_falsey
+    expect(Pebblebed::Uid.valid_klass?("")).to be_falsey
   end
 
   describe "validating paths" do
-    specify { Pebblebed::Uid.valid_path?("").should be_true }
-    specify { Pebblebed::Uid.valid_path?("abc123").should be_true }
-    specify { Pebblebed::Uid.valid_path?("abc.123").should be_true }
-    specify { Pebblebed::Uid.valid_path?("abc.de-f.123").should be_true }
+    specify { expect(Pebblebed::Uid.valid_path?("")).to be_truthy }
+    specify { expect(Pebblebed::Uid.valid_path?("abc123")).to be_truthy }
+    specify { expect(Pebblebed::Uid.valid_path?("abc.123")).to be_truthy }
+    specify { expect(Pebblebed::Uid.valid_path?("abc.de-f.123")).to be_truthy }
 
-    specify { Pebblebed::Uid.valid_path?("abc!.").should be_false }
-    specify { Pebblebed::Uid.valid_path?(".").should be_false }
-    specify { Pebblebed::Uid.valid_path?("ab. 123").should be_false }
+    specify { expect(Pebblebed::Uid.valid_path?("abc!.")).to be_falsey }
+    specify { expect(Pebblebed::Uid.valid_path?(".")).to be_falsey }
+    specify { expect(Pebblebed::Uid.valid_path?("ab. 123")).to be_falsey }
 
     context "with wildcards" do
-      specify { Pebblebed::Uid.valid_path?('*').should be_true }
-      specify { Pebblebed::Uid.valid_path?('a.b.c.*').should be_true }
-      specify { Pebblebed::Uid.valid_path?('a.b|c.d').should be_true }
-      specify { Pebblebed::Uid.valid_path?('a.b|c.*').should be_true }
-      specify { Pebblebed::Uid.valid_path?('^a').should be_true }
-      specify { Pebblebed::Uid.valid_path?('^a.b').should be_true }
-      specify { Pebblebed::Uid.valid_path?('^a.b.c').should be_true }
-      specify { Pebblebed::Uid.valid_path?('a.^b.c').should be_true }
-      specify { Pebblebed::Uid.valid_path?('a.^b.c|d.e').should be_true }
-      specify { Pebblebed::Uid.valid_path?('a.^b.c.*').should be_true }
-
-      specify { Pebblebed::Uid.valid_path?('*a').should be_false }
-      specify { Pebblebed::Uid.valid_path?('a*').should be_false }
-      specify { Pebblebed::Uid.valid_path?('*.b').should be_false }
-      specify { Pebblebed::Uid.valid_path?('a.*.b').should be_false }
-      specify { Pebblebed::Uid.valid_path?('|').should be_false }
-      specify { Pebblebed::Uid.valid_path?('a.|b').should be_false }
-      specify { Pebblebed::Uid.valid_path?('a.b|').should be_false }
-      specify { Pebblebed::Uid.valid_path?('a.|b.c').should be_false }
-      specify { Pebblebed::Uid.valid_path?('a.b|.c').should be_false }
-      specify { Pebblebed::Uid.valid_path?('^').should be_false }
-      specify { Pebblebed::Uid.valid_path?('^.a').should be_false }
-      specify { Pebblebed::Uid.valid_path?('a^').should be_false }
-      specify { Pebblebed::Uid.valid_path?('a^b.c').should be_false }
+      specify { expect(Pebblebed::Uid.valid_path?('*')).to be_truthy }
+      specify { expect(Pebblebed::Uid.valid_path?('a.b.c.*')).to be_truthy }
+      specify { expect(Pebblebed::Uid.valid_path?('a.b|c.d')).to be_truthy }
+      specify { expect(Pebblebed::Uid.valid_path?('a.b|c.*')).to be_truthy }
+      specify { expect(Pebblebed::Uid.valid_path?('^a')).to be_truthy }
+      specify { expect(Pebblebed::Uid.valid_path?('^a.b')).to be_truthy }
+      specify { expect(Pebblebed::Uid.valid_path?('^a.b.c')).to be_truthy }
+      specify { expect(Pebblebed::Uid.valid_path?('a.^b.c')).to be_truthy }
+      specify { expect(Pebblebed::Uid.valid_path?('a.^b.c|d.e')).to be_truthy }
+      specify { expect(Pebblebed::Uid.valid_path?('a.^b.c.*')).to be_truthy }
+
+      specify { expect(Pebblebed::Uid.valid_path?('*a')).to be_falsey }
+      specify { expect(Pebblebed::Uid.valid_path?('a*')).to be_falsey }
+      specify { expect(Pebblebed::Uid.valid_path?('*.b')).to be_falsey }
+      specify { expect(Pebblebed::Uid.valid_path?('a.*.b')).to be_falsey }
+      specify { expect(Pebblebed::Uid.valid_path?('|')).to be_falsey }
+      specify { expect(Pebblebed::Uid.valid_path?('a.|b')).to be_falsey }
+      specify { expect(Pebblebed::Uid.valid_path?('a.b|')).to be_falsey }
+      specify { expect(Pebblebed::Uid.valid_path?('a.|b.c')).to be_falsey }
+      specify { expect(Pebblebed::Uid.valid_path?('a.b|.c')).to be_falsey }
+      specify { expect(Pebblebed::Uid.valid_path?('^')).to be_falsey }
+      specify { expect(Pebblebed::Uid.valid_path?('^.a')).to be_falsey }
+      specify { expect(Pebblebed::Uid.valid_path?('a^')).to be_falsey }
+      specify { expect(Pebblebed::Uid.valid_path?('a^b.c')).to be_falsey }
     end
   end
 
   describe "wildcard paths" do
-    specify { Pebblebed::Uid.wildcard_path?('*').should be_true }
-    specify { Pebblebed::Uid.wildcard_path?('a.b|c.d').should be_true }
-    specify { Pebblebed::Uid.wildcard_path?('a.^b.d').should be_true }
-    specify { Pebblebed::Uid.wildcard_path?('a.b.d').should be_false }
+    specify { expect(Pebblebed::Uid.wildcard_path?('*')).to be_truthy }
+    specify { expect(Pebblebed::Uid.wildcard_path?('a.b|c.d')).to be_truthy }
+    specify { expect(Pebblebed::Uid.wildcard_path?('a.^b.d')).to be_truthy }
+    specify { expect(Pebblebed::Uid.wildcard_path?('a.b.d')).to be_falsey }
   end
 
   describe "parsing in place" do
-    specify { Pebblebed::Uid.parse("klass:path$oid").should eq ['klass', 'path', 'oid'] }
-    specify { Pebblebed::Uid.parse("post:this.is.a.path.to$object_id").should eq ['post', 'this.is.a.path.to', 'object_id'] }
-    specify { Pebblebed::Uid.parse("post:$object_id").should eq ['post', nil, 'object_id'] }
+    specify { expect(Pebblebed::Uid.parse("klass:path$oid")).to eq ['klass', 'path', 'oid'] }
+    specify { expect(Pebblebed::Uid.parse("post:this.is.a.path.to$object_id")).to eq ['post', 'this.is.a.path.to', 'object_id'] }
+    specify { expect(Pebblebed::Uid.parse("post:$object_id")).to eq ['post', nil, 'object_id'] }
   end
 
   describe "validating uids" do
-    specify { Pebblebed::Uid.valid?("a:b.c.d$e").should be_true }
-    specify { Pebblebed::Uid.valid?("a:$e").should be_true }
-    specify { Pebblebed::Uid.valid?("a:b.c.d").should be_true }
-    specify { Pebblebed::Uid.valid?("F**ing H%$#!!!").should be_false }
-    specify { Pebblebed::Uid.valid?("").should be_false }
-    specify { Pebblebed::Uid.valid?("bang:").should be_false }
-    specify { Pebblebed::Uid.valid?(":bang").should be_false }
-    specify { Pebblebed::Uid.valid?(":bang$paff").should be_false }
-    specify { Pebblebed::Uid.valid?("$paff").should be_false }
+    specify { expect(Pebblebed::Uid.valid?("a:b.c.d$e")).to be_truthy }
+    specify { expect(Pebblebed::Uid.valid?("a:$e")).to be_truthy }
+    specify { expect(Pebblebed::Uid.valid?("a:b.c.d")).to be_truthy }
+    specify { expect(Pebblebed::Uid.valid?("F**ing H%$#!!!")).to be_falsey }
+    specify { expect(Pebblebed::Uid.valid?("")).to be_falsey }
+    specify { expect(Pebblebed::Uid.valid?("bang:")).to be_falsey }
+    specify { expect(Pebblebed::Uid.valid?(":bang")).to be_falsey }
+    specify { expect(Pebblebed::Uid.valid?(":bang$paff")).to be_falsey }
+    specify { expect(Pebblebed::Uid.valid?("$paff")).to be_falsey }
   end
 
   describe "extracting realm from path" do
-    specify { Pebblebed::Uid.new("klass:realm.other.stuff$3").realm.should eq 'realm' }
-    specify { Pebblebed::Uid.new("klass:realm$3").realm.should eq 'realm' }
-    specify { Pebblebed::Uid.new("klass:realm").realm.should eq 'realm' }
-    specify { Pebblebed::Uid.new("klass:$3").realm.should eq nil }
+    specify { expect(Pebblebed::Uid.new("klass:realm.other.stuff$3").realm).to eq 'realm' }
+    specify { expect(Pebblebed::Uid.new("klass:realm$3").realm).to eq 'realm' }
+    specify { expect(Pebblebed::Uid.new("klass:realm").realm).to eq 'realm' }
+    specify { expect(Pebblebed::Uid.new("klass:$3").realm).to eq nil }
   end
 
   describe "equality" do
     let(:uid) { "klass:realm$3" }
     it "is dependent on the actual uid" do
-      Pebblebed::Uid.new("klass:realm$3").should eq Pebblebed::Uid.new("klass:realm$3")
+      expect(Pebblebed::Uid.new("klass:realm$3")).to eq Pebblebed::Uid.new("klass:realm$3")
     end
 
     it "also works for eql?" do
-      Pebblebed::Uid.new("klass:realm$3").eql?(Pebblebed::Uid.new("klass:realm$3")).should be_true
+      expect(Pebblebed::Uid.new("klass:realm$3").eql?(Pebblebed::Uid.new("klass:realm$3"))).to be_truthy
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pebblebed
 version: !ruby/object:Gem::Version
-  version: 0.3.7
+  version: 0.3.8
 platform: ruby
 authors:
 - Katrina Owen
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-07-23 00:00:00.000000000 Z
+date: 2016-08-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -289,7 +289,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: pebblebed
-rubygems_version: 2.2.5
+rubygems_version: 2.4.5.1
 signing_key: 
 specification_version: 4
 summary: Development tools for working with Pebblebed
@@ -309,4 +309,3 @@ test_files:
 - spec/sinatra_spec.rb
 - spec/spec_helper.rb
 - spec/uid_spec.rb
-has_rdoc: