springboard-retail 4.0.0 → 4.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 87e9ec06faad25bd8e8039f40af91e2152eeebdc
-  data.tar.gz: 97c4703a8894e57572c4a3f9cd8decae97951f8f
+  metadata.gz: 749ec3a018626e45895cdf3ce674d69ac06803b2
+  data.tar.gz: 8e779076c490e2d7d331b0488a8b7a28a054b843
 SHA512:
-  metadata.gz: 0396c1a84ffc53e91424bec9fb7c095cd9ba5e955c7339d900e5fb488faeea1146cec6de0ca5c3cab74bf3bc9fd6b189596c875e20d469e312af8f0b418dd7dd
-  data.tar.gz: 65d39bd20a9206d286820502a205309fc15d8228711e2a79ce6b9f316659449aa2611475f5e9d9e7ba23e2a3cb71abda94f4c211d74bff90083afaba02a0feb0
+  metadata.gz: 6c96e952949e093a9703cce11b9db9e17662eae0f49fecb37775c680d15623760bc5e749f84a16e24bc0abec06e83967bda583ef4cfe341b042e9e4cc4633255
+  data.tar.gz: edff0014f54cae6814448300aa2eb396f984e9140de482b35a09469cb76cb273da5b751258f33b81e1ec8a1750cab283a6b16b57a7d1d8550058a36ad422d635

data/.travis.yml

@@ -3,3 +3,5 @@ bundler_args: --without development
 rvm:
   - 1.9.3
   - 2.0.0
+  - 2.1.0
+  - 2.2.0

data/Gemfile

@@ -4,7 +4,7 @@ gemspec
 
 group :test do
   gem 'rake'
-  gem 'rspec', '~> 2.11'
+  gem 'rspec', '~> 3.2'
   gem 'webmock', :require => false
   gem 'coveralls', :require => false
 end

data/Gemfile.lock

@@ -1,58 +1,69 @@
 PATH
   remote: .
   specs:
-    springboard-retail (4.0.0)
-      addressable (>= 2.2.8)
+    springboard-retail (4.0.1)
+      addressable (~> 2.2.8)
       hashie
       json (>= 1.7.4)
-      patron (>= 0.4.18)
+      patron (= 0.4.18)
 
 GEM
   remote: https://rubygems.org/
   specs:
     addressable (2.2.8)
-    coderay (1.0.7)
-    coveralls (0.6.9)
-      multi_json (~> 1.3)
-      rest-client
-      simplecov (>= 0.7)
-      term-ansicolor
-      thor
-    crack (0.3.1)
-    diff-lcs (1.1.3)
-    hashie (2.0.5)
-    json (1.8.1)
-    method_source (0.8)
-    mime-types (1.25)
-    multi_json (1.8.0)
+    coderay (1.1.0)
+    coveralls (0.7.11)
+      multi_json (~> 1.10)
+      rest-client (>= 1.6.8, < 2)
+      simplecov (~> 0.9.1)
+      term-ansicolor (~> 1.3)
+      thor (~> 0.19.1)
+    crack (0.4.2)
+      safe_yaml (~> 1.0.0)
+    diff-lcs (1.2.5)
+    docile (1.1.5)
+    hashie (3.4.1)
+    json (1.8.2)
+    method_source (0.8.2)
+    mime-types (2.4.3)
+    multi_json (1.11.0)
+    netrc (0.10.3)
     patron (0.4.18)
-    pry (0.9.10)
-      coderay (~> 1.0.5)
-      method_source (~> 0.8)
-      slop (~> 3.3.1)
-    rake (0.9.2.2)
-    rest-client (1.6.7)
-      mime-types (>= 1.16)
-    rspec (2.11.0)
-      rspec-core (~> 2.11.0)
-      rspec-expectations (~> 2.11.0)
-      rspec-mocks (~> 2.11.0)
-    rspec-core (2.11.1)
-    rspec-expectations (2.11.2)
-      diff-lcs (~> 1.1.3)
-    rspec-mocks (2.11.1)
-    simplecov (0.7.1)
+    pry (0.10.1)
+      coderay (~> 1.1.0)
+      method_source (~> 0.8.1)
+      slop (~> 3.4)
+    rake (10.4.2)
+    rest-client (1.7.3)
+      mime-types (>= 1.16, < 3.0)
+      netrc (~> 0.7)
+    rspec (3.2.0)
+      rspec-core (~> 3.2.0)
+      rspec-expectations (~> 3.2.0)
+      rspec-mocks (~> 3.2.0)
+    rspec-core (3.2.2)
+      rspec-support (~> 3.2.0)
+    rspec-expectations (3.2.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.2.0)
+    rspec-mocks (3.2.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.2.0)
+    rspec-support (3.2.2)
+    safe_yaml (1.0.4)
+    simplecov (0.9.2)
+      docile (~> 1.1.0)
       multi_json (~> 1.0)
-      simplecov-html (~> 0.7.1)
-    simplecov-html (0.7.1)
-    slop (3.3.2)
-    term-ansicolor (1.2.2)
-      tins (~> 0.8)
-    thor (0.18.1)
-    tins (0.9.0)
-    webmock (1.8.8)
-      addressable (~> 2.2.8)
-      crack (>= 0.1.7)
+      simplecov-html (~> 0.9.0)
+    simplecov-html (0.9.0)
+    slop (3.6.0)
+    term-ansicolor (1.3.0)
+      tins (~> 1.0)
+    thor (0.19.1)
+    tins (1.3.5)
+    webmock (1.17.4)
+      addressable (>= 2.2.7)
+      crack (>= 0.3.2)
 
 PLATFORMS
   ruby
@@ -61,6 +72,6 @@ DEPENDENCIES
   coveralls
   pry
   rake
-  rspec (~> 2.11)
+  rspec (~> 3.2)
   springboard-retail!
   webmock

data/README.md

@@ -10,7 +10,7 @@ This is the [Springboard Retail](http://springboardretail.com/) (a point-of-sale
 
 It is a wrapper around the [Patron](http://toland.github.com/patron/) HTTP client library. Supports MRI 1.9+.
 
-You can find [documentation here](http://rdoc.info/github/springboard/springboard-client-ruby).
+You can find [documentation here](http://rdoc.info/github/springboardretail/springboard-client-ruby).
 
 ## Installation
 
@@ -20,13 +20,14 @@ Debian/Ubuntu:
 
 ```
 sudo apt-get install build-essential libcurl4-openssl-dev
-gem install springboard-client
+gem install springboard-retail
 ```
 
 ## Connecting
 
 ```ruby
-springboard = Springboard::Client.new 'http://example.springboard.us/api'
+require 'springboard-retail'
+springboard = Springboard::Client.new 'https://example.myspringboard.us/api'
 springboard.auth :username => 'user', :password => 'secret'
 ```
 

data/spec/springboard/client/body_spec.rb

@@ -6,26 +6,26 @@ describe Springboard::Client::Body do
 
   describe "[]" do
     it "should support string keys" do
-      body["key1"].should == "val1"
+      expect(body["key1"]).to eq("val1")
     end
 
     it "should support symbol keys" do
-      body[:key1].should == "val1"
+      expect(body[:key1]).to eq("val1")
     end
   end
 
   describe "nested hashes" do
     it "should support nested indifferent access" do
-      body[:key2][:subkey1].should == "subval1"
-      body['key2']['subkey1'].should == "subval1"
-      body[:key2]['subkey1'].should == "subval1"
-      body['key2'][:subkey1].should == "subval1"
+      expect(body[:key2][:subkey1]).to eq("subval1")
+      expect(body['key2']['subkey1']).to eq("subval1")
+      expect(body[:key2]['subkey1']).to eq("subval1")
+      expect(body['key2'][:subkey1]).to eq("subval1")
     end
   end
 
   describe "to_hash" do
     it "should return the original hash" do
-      body.to_hash.should === hash
+      expect(body.to_hash).to be === hash
     end
   end
 end

data/spec/springboard/client/resource_spec.rb

@@ -12,28 +12,28 @@ describe Springboard::Client::Resource do
 
   describe "[]" do
     it "should return a new resource" do
-      resource["subpath"].should be_a Springboard::Client::Resource
-      resource["subpath"].object_id.should_not == resource.object_id
+      expect(resource["subpath"]).to be_a Springboard::Client::Resource
+      expect(resource["subpath"].object_id).not_to eq(resource.object_id)
     end
 
     it "should return a resource with the given subpath appended to its URI" do
-      resource["subpath"].uri.to_s.should == "/some/path/subpath"
+      expect(resource["subpath"].uri.to_s).to eq("/some/path/subpath")
     end
 
     it "should return a resource with the same client instance" do
-      resource["subpath"].client.should === resource.client
+      expect(resource["subpath"].client).to be === resource.client
     end
 
     it "should accept a symbol as a path" do
-      resource[:subpath].uri.to_s.should == "/some/path/subpath"
+      expect(resource[:subpath].uri.to_s).to eq("/some/path/subpath")
     end
 
     it "should accept a symbol as a path" do
-      resource[:subpath].uri.to_s.should == "/some/path/subpath"
+      expect(resource[:subpath].uri.to_s).to eq("/some/path/subpath")
     end
 
     it "should not URI encode the given subpath" do
-      resource["subpath with spaces"].uri.to_s.should == "/some/path/subpath with spaces"
+      expect(resource["subpath with spaces"].uri.to_s).to eq("/some/path/subpath with spaces")
     end
   end
 
@@ -41,24 +41,24 @@ describe Springboard::Client::Resource do
     describe method do
       describe "when called with a hash" do
         it "should set the query string parameters" do
-          resource.__send__(method, :a => 1, :b => 2).uri.to_s.should == "/some/path?a=1&b=2"
+          expect(resource.__send__(method, :a => 1, :b => 2).uri.to_s).to eq("/some/path?a=1&b=2")
         end
 
         it "should URL encode the given keys and values" do
-          resource.__send__(method, "i have spaces" => "so do i: duh").uri.to_s.
-            should == "/some/path?i%20have%20spaces=so%20do%20i%3A%20duh"
+          expect(resource.__send__(method, "i have spaces" => "so do i: duh").uri.to_s).
+            to eq("/some/path?i%20have%20spaces=so%20do%20i%3A%20duh")
         end
 
         it "should add bracket notation for array parameters" do
-          resource.__send__(method, :somearray => [1, 2, 3]).uri.to_s.should == "/some/path?somearray[]=1&somearray[]=2&somearray[]=3"
+          expect(resource.__send__(method, :somearray => [1, 2, 3]).uri.to_s).to eq("/some/path?somearray[]=1&somearray[]=2&somearray[]=3")
         end
       end
 
       describe "when called without arguments" do
         it "should return the current query string parameters as a hash" do
-          resource.__send__(method).should == {}
+          expect(resource.__send__(method)).to eq({})
           new_resource = resource.__send__(method, :a => 1, :b => 2)
-          new_resource.__send__(method).should == {"a"=>"1", "b"=>"2"}
+          expect(new_resource.__send__(method)).to eq({"a"=>"1", "b"=>"2"})
         end
       end
     end
@@ -67,41 +67,44 @@ describe Springboard::Client::Resource do
   describe "filter" do
     describe "when given a hash" do
       it "should add a _filter query string param" do
-        resource.filter(:a => 1, :b => 2).uri.should ==
+        expect(resource.filter(:a => 1, :b => 2).uri).to eq(
           '/some/path?_filter={"a":1,"b":2}'.to_uri
+        )
       end
     end
 
     describe "when called multiple times" do
       it "should append args to _filter param as JSON array" do
-        resource.filter(:a => 1).filter(:b => 2).filter(:c => 3).uri.should ==
+        expect(resource.filter(:a => 1).filter(:b => 2).filter(:c => 3).uri).to eq(
           '/some/path?_filter=[{"a":1},{"b":2},{"c":3}]'.to_uri
+        )
       end
     end
 
     describe "when given a string" do
       it "should add a _filter query string param" do
-        resource.filter('{"a":1,"b":2}').uri.should ==
+        expect(resource.filter('{"a":1,"b":2}').uri).to eq(
           '/some/path?_filter={"a":1,"b":2}'.to_uri
+        )
       end
     end
   end
 
   describe "sort" do
     it "should set the sort parameter based on the given values" do
-      resource.sort('f1', 'f2,desc').uri.query.should == 'sort[]=f1&sort[]=f2%2Cdesc'
+      expect(resource.sort('f1', 'f2,desc').uri.query).to eq('sort[]=f1&sort[]=f2%2Cdesc')
     end
 
     it "should replace any existing sort parameter" do
       resource.sort('f1', 'f2,desc')
-      resource.sort('f3,asc', 'f4').uri.query.should == 'sort[]=f3%2Casc&sort[]=f4'
+      expect(resource.sort('f3,asc', 'f4').uri.query).to eq('sort[]=f3%2Casc&sort[]=f4')
     end
   end
 
   %w{count each each_page}.each do |method|
     describe method do
       it "should call the client's #{method} method with the resource's URI" do
-        client.should_receive(method).with(resource.uri)
+        expect(client).to receive(method).with(resource.uri)
         resource.__send__(method)
       end
     end
@@ -110,7 +113,7 @@ describe Springboard::Client::Resource do
   %w{get head delete}.each do |method|
     describe method do
       it "should call the client's #{method} method with the resource's URI and a header hash" do
-        client.should_receive(method).with(resource.uri, false)
+        expect(client).to receive(method).with(resource.uri, false)
         resource.__send__(method)
       end
     end
@@ -119,7 +122,7 @@ describe Springboard::Client::Resource do
   %w{put post}.each do |method|
     describe method do
       it "should call the client's #{method} method with the resource's URI, the given body, and a headers hash" do
-        client.should_receive(method).with(resource.uri, "body", false)
+        expect(client).to receive(method).with(resource.uri, "body", false)
         resource.__send__(method, "body")
       end
     end
@@ -136,39 +139,44 @@ describe Springboard::Client::Resource do
     it "should set the per_page query string param to 1" do
       request_stub = stub_request(:get, "#{base_url}/some/path?page=1&per_page=1").to_return(response_data)
       resource.first
-      request_stub.should have_been_requested
+      expect(request_stub).to have_been_requested
     end
 
     it "should return the first element of the :results array" do
       request_stub = stub_request(:get, "#{base_url}/some/path?page=1&per_page=1").to_return(response_data)
-      resource.first.should == {"id" => "Me first!"}
+      expect(resource.first).to eq({"id" => "Me first!"})
     end
   end
 
   describe "embed" do
     it "should support a single embed" do
-      resource.embed(:thing1).uri.to_s.should ==
+      expect(resource.embed(:thing1).uri.to_s).to eq(
         '/some/path?_include[]=thing1'
+      )
     end
 
     it "should support multiple embeds" do
-      resource.embed(:thing1, :thing2, :thing3).uri.to_s.should ==
+      expect(resource.embed(:thing1, :thing2, :thing3).uri.to_s).to eq(
         '/some/path?_include[]=thing1&_include[]=thing2&_include[]=thing3'
+      )
     end
 
     it "should merge multiple embed calls" do
-      resource.embed(:thing1, :thing2).embed(:thing3, :thing4).uri.to_s.should ==
+      expect(resource.embed(:thing1, :thing2).embed(:thing3, :thing4).uri.to_s).to eq(
         '/some/path?_include[]=thing1&_include[]=thing2&_include[]=thing3&_include[]=thing4'
+      )
     end
 
     it "should merge multiple embed calls" do
-      resource.embed(:thing1, :thing2).embed(:thing3, :thing4).uri.to_s.should ==
+      expect(resource.embed(:thing1, :thing2).embed(:thing3, :thing4).uri.to_s).to eq(
         '/some/path?_include[]=thing1&_include[]=thing2&_include[]=thing3&_include[]=thing4'
+      )
     end
 
     it "should merge a call to embed with a manually added _include query param" do
-      resource.query('_include[]' => :thing1).embed(:thing2, :thing3).uri.to_s.should ==
+      expect(resource.query('_include[]' => :thing1).embed(:thing2, :thing3).uri.to_s).to eq(
         '/some/path?_include[]=thing1&_include[]=thing2&_include[]=thing3'
+      )
     end
   end
 
@@ -183,13 +191,13 @@ describe Springboard::Client::Resource do
       yielded_results = []
 
       # timeout in case of endless loop
-      Timeout::timeout(1) do
+      Timeout::timeout(10) do
         resource.while_results do |result|
           yielded_results.push results.shift
         end
       end
 
-      yielded_results.should == ["r1", "r2", "r3"]
+      expect(yielded_results).to eq(["r1", "r2", "r3"])
     end
 
     it "should raise an exception if it receives an error response" do
@@ -198,7 +206,7 @@ describe Springboard::Client::Resource do
       end
 
       # timeout in case of endless loop
-      Timeout::timeout(1) do
+      Timeout::timeout(10) do
         expect do
           resource.while_results do |result|
             # nothing
@@ -208,42 +216,42 @@ describe Springboard::Client::Resource do
     end
 
     describe "exists?" do
-      let(:response) { mock(Springboard::Client::Response) }
+      let(:response) { double(Springboard::Client::Response) }
 
       it "should return true if the response indicates success" do
-        response.stub!(:success?).and_return(true)
-        client.should_receive(:head).with(resource.uri, false).and_return(response)
-        resource.exists?.should === true
+        allow(response).to receive(:success?).and_return(true)
+        expect(client).to receive(:head).with(resource.uri, false).and_return(response)
+        expect(resource.exists?).to be === true
       end
 
       it "should return false if the response status is 404" do
-        response.stub!(:status).and_return(404)
-        response.stub!(:success?).and_return(false)
-        client.should_receive(:head).with(resource.uri, false).and_return(response)
-        resource.exists?.should === false
+        allow(response).to receive(:status).and_return(404)
+        allow(response).to receive(:success?).and_return(false)
+        expect(client).to receive(:head).with(resource.uri, false).and_return(response)
+        expect(resource.exists?).to be === false
       end
 
       it "should raise a RequestFailed exception if the request fails but the status is not 404" do
-        response.stub!(:status).and_return(400)
-        response.stub!(:success?).and_return(false)
-        client.should_receive(:head).with(resource.uri, false).and_return(response)
+        allow(response).to receive(:status).and_return(400)
+        allow(response).to receive(:success?).and_return(false)
+        expect(client).to receive(:head).with(resource.uri, false).and_return(response)
         expect { resource.exists? }.to raise_error { |e|
-          e.should be_a Springboard::Client::RequestFailed
-          e.response.should === response
-          e.message.should == "Request during call to 'exists?' resulted in non-404 error."
+          expect(e).to be_a Springboard::Client::RequestFailed
+          expect(e.response).to be === response
+          expect(e.message).to eq("Request during call to 'exists?' resulted in non-404 error.")
         }
       end
     end
 
     describe "empty?" do
       it "should return true if the resource has a count of zero" do
-        resource.stub!(:count).and_return 0
-        resource.empty?.should === true
+        allow(resource).to receive(:count).and_return 0
+        expect(resource.empty?).to be === true
       end
 
       it "should return false if the resource has a count greater than zero" do
-        resource.stub!(:count).and_return 10
-        resource.empty?.should === false
+        allow(resource).to receive(:count).and_return 10
+        expect(resource.empty?).to be === false
       end
     end
   end

data/spec/springboard/client/response_spec.rb

@@ -13,11 +13,11 @@ describe Springboard::Client::Response do
   describe "body" do
     describe "if raw body is valid JSON" do
       it "should return a Springboard::Client::Body" do
-        response.body.should be_a Springboard::Client::Body
+        expect(response.body).to be_a Springboard::Client::Body
       end
 
       it "should wrap the parsed response body" do
-        response.body.to_hash.should == {"key" => "value"}
+        expect(response.body.to_hash).to eq({"key" => "value"})
       end
     end
 
@@ -42,13 +42,13 @@ describe Springboard::Client::Response do
 
   describe "raw_body" do
     it "should return the raw body JSON" do
-      response.raw_body.should == raw_body
+      expect(response.raw_body).to eq(raw_body)
     end
   end
 
   describe "headers" do
     it "should return the response headers as a hash" do
-      response.headers.should == {'X-Custom-Header' => 'Hi'}
+      expect(response.headers).to eq({'X-Custom-Header' => 'Hi'})
     end
   end
 
@@ -57,11 +57,11 @@ describe Springboard::Client::Response do
       let(:raw_headers) { 'Location: /new/path' }
 
       it "should be a Springboard::Client::Resource" do
-        response.resource.should be_a Springboard::Client::Resource
+        expect(response.resource).to be_a Springboard::Client::Resource
       end
 
       it "should have the Location header value as its URL" do
-        response.resource.uri.to_s.should == '/new/path'
+        expect(response.resource.uri.to_s).to eq('/new/path')
       end
     end
 
@@ -69,31 +69,31 @@ describe Springboard::Client::Response do
       let(:raw_headers) { '' }
 
       it "should be nil" do
-        response.resource.should be_nil
+        expect(response.resource).to be_nil
       end
     end
   end
 
   describe "[]" do
     it "should forward [] to body" do
-      response.body.should_receive(:[]).with("key").and_return("value")
-      response["key"].should == "value"
+      expect(response.body).to receive(:[]).with("key").and_return("value")
+      expect(response["key"]).to eq("value")
     end
   end
 
   describe "success?" do
     %w{100 101 102 200 201 202 203 204 205 206 207 208 226 300 301 302 303 304 305 306 307 308}.each do |code|
       it "should return true if the response status code is #{code}" do
-        response.stub!(:status).and_return(code.to_i)
-        response.success?.should === true
+        allow(response).to receive(:status).and_return(code.to_i)
+        expect(response.success?).to be === true
       end
     end
 
     %w{400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 420 422 423 424 425 426 428 429 431
        444 449 450 499 500 501 502 503 504 505 506 507 508 509 510 511 598 599}.each do |code|
       it "should return false if the response status code is #{code}" do
-        response.stub!(:status).and_return(code.to_i)
-        response.success?.should === false
+        allow(response).to receive(:status).and_return(code.to_i)
+        expect(response.success?).to be === false
       end
     end
   end

data/spec/springboard/client/uri_ext_spec.rb

@@ -5,8 +5,8 @@ describe Addressable::URI do
 
   describe "subpath" do
     it "should return a new URI with the path relative to the receiver" do
-      uri.subpath('other').should == Addressable::URI.parse('/relative/path/other')
-      uri.subpath('/other').should == Addressable::URI.parse('/relative/path/other')
+      expect(uri.subpath('other')).to eq(Addressable::URI.parse('/relative/path/other'))
+      expect(uri.subpath('/other')).to eq(Addressable::URI.parse('/relative/path/other'))
       uri.subpath(Addressable::URI.parse('/other')) == Addressable::URI.parse('/relative/path/other')
     end
   end
@@ -14,20 +14,20 @@ describe Addressable::URI do
   describe "merge_query_values!" do
     it "should call springboard_query_values=" do
       uri.query_values = {'a' => '1'}
-      uri.should_receive(:springboard_query_values=).with({'a' => '1', 'b' => '2'})
+      expect(uri).to receive(:springboard_query_values=).with({'a' => '1', 'b' => '2'})
       uri.merge_query_values! 'b' => '2'
     end
 
     it "should merge the given values with the existing query_values" do
       uri.query_values = {'a' => '1', 'b' => '2'}
       uri.merge_query_values! 'b' => '20', 'c' => '30'
-      uri.query_values.should == {'a' => '1', 'b' => '20', 'c' => '30'}
+      expect(uri.query_values).to eq({'a' => '1', 'b' => '20', 'c' => '30'})
     end
 
     it "should set the given values if there are no existing query_values" do
-      uri.query_values.should be_nil
+      expect(uri.query_values).to be_nil
       uri.merge_query_values! 'b' => '20', 'c' => '30'
-      uri.query_values.should == {'b' => '20', 'c' => '30'}
+      expect(uri.query_values).to eq({'b' => '20', 'c' => '30'})
     end
   end
 
@@ -35,17 +35,17 @@ describe Addressable::URI do
     it "should preserve empty bracket notation for array params" do
       uri.query = 'sort[]=f1&sort[]=f2'
       uri.__send__(:springboard_query_values=, uri.query_values)
-      uri.to_s.should == '/relative/path?sort[]=f1&sort[]=f2'
+      expect(uri.to_s).to eq('/relative/path?sort[]=f1&sort[]=f2')
     end
 
     it "should stringify boolean param values" do
       uri.__send__(:springboard_query_values=, {:p1 => true, :p2 => false})
-      uri.to_s.should == '/relative/path?p1=true&p2=false'
+      expect(uri.to_s).to eq('/relative/path?p1=true&p2=false')
     end
 
     it "should support hash param values" do
       uri.__send__(:springboard_query_values=, {:a => {:b => {:c => 123}}})
-      uri.to_s.should == '/relative/path?a[b][c]=123'
+      expect(uri.to_s).to eq('/relative/path?a[b][c]=123')
     end
   end
 end

data/spec/springboard/client_spec.rb

@@ -5,7 +5,7 @@ describe Springboard::Client do
 
   describe "session" do
     it "should be a Patron::Session" do
-      client.session.should be_a Patron::Session
+      expect(client.session).to be_a Patron::Session
     end
   end
 
@@ -15,64 +15,64 @@ describe Springboard::Client do
         :body => "auth_key=coco&password=boggle",
         :headers => {'Content-Type' => 'application/x-www-form-urlencoded'}
       client.auth(:username => 'coco', :password => 'boggle')
-      request_stub.should have_been_requested
+      expect(request_stub).to have_been_requested
     end
 
     it "should raise an exception if called without username or password" do
-      lambda { client.auth }.should raise_error("Must specify :username and :password")
-      lambda { client.auth(:username => 'x') }.should raise_error("Must specify :username and :password")
-      lambda { client.auth(:password => 'y') }.should raise_error("Must specify :username and :password")
+      expect { client.auth }.to raise_error("Must specify :username and :password")
+      expect { client.auth(:username => 'x') }.to raise_error("Must specify :username and :password")
+      expect { client.auth(:password => 'y') }.to raise_error("Must specify :username and :password")
     end
 
     it "should return true if auth succeeds" do
       stub_request(:post, "#{base_url}/auth/identity/callback").to_return(:status => 200)
-      lambda { client.auth(:username => 'someone', :password => 'right') }.should be_true
+      expect(client.auth(:username => 'someone', :password => 'right')).to be_truthy
     end
 
     it "should raise an AuthFailed if auth fails" do
       stub_request(:post, "#{base_url}/auth/identity/callback").to_return(:status => 401)
-      lambda { client.auth(:username => 'someone', :password => 'wrong') }.should \
+      expect { client.auth(:username => 'someone', :password => 'wrong') }.to \
         raise_error(Springboard::Client::AuthFailed, "Springboard auth failed")
     end
   end
 
   describe "initialize" do
     it "should call configure_session" do
-      Springboard::Client.any_instance.should_receive(:configure_session).with(base_url, {:x => 'y'})
+      expect_any_instance_of(Springboard::Client).to receive(:configure_session).with(base_url, {:x => 'y'})
       Springboard::Client.new(base_url, :x => 'y')
     end
   end
 
   describe "configure_session" do
     it "should set the session's base_url" do
-      session.should_receive(:base_url=).with(base_url)
+      expect(session).to receive(:base_url=).with(base_url)
       client.__send__(:configure_session, base_url, :x => 'y')
     end
 
     it "should enable cookies" do
-      session.should_receive(:handle_cookies)
+      expect(session).to receive(:handle_cookies)
       client.__send__(:configure_session, base_url, :x => 'y')
     end
 
     it "should allow setting insecure on the session" do
-      session.should_receive(:insecure=).with(true)
+      expect(session).to receive(:insecure=).with(true)
       client.__send__(:configure_session, base_url, :insecure => true)
     end
 
     it "set the default timeout" do
       client.__send__(:configure_session, base_url, {})
-      client.session.timeout.should == Springboard::Client::DEFAULT_TIMEOUT
+      expect(client.session.timeout).to eq(Springboard::Client::DEFAULT_TIMEOUT)
     end
 
     it "set the default connect timeout" do
       client.__send__(:configure_session, base_url, {})
-      client.session.connect_timeout.should == Springboard::Client::DEFAULT_CONNECT_TIMEOUT
+      expect(client.session.connect_timeout).to eq(Springboard::Client::DEFAULT_CONNECT_TIMEOUT)
     end
   end
 
   describe "[]" do
     it "should return a resource object with the given path and client" do
-      client["path"].should be_a Springboard::Client::Resource
+      expect(client["path"]).to be_a Springboard::Client::Resource
     end
   end
 
@@ -81,37 +81,37 @@ describe Springboard::Client do
     bang_method = "#{method}!"
     describe method do
       it "should call session's #{method}" do
-        session.should_receive(method).with('/relative/path')
+        expect(session).to receive(method).with('/relative/path')
         client.__send__(method, '/relative/path')
       end
 
       it "should return a Springboard::Client::Response" do
-        request_stub = stub_request(method, "#{base_url}/relative/path")
+        stub_request(method, "#{base_url}/relative/path")
         response = client.__send__(method, '/relative/path')
-        response.should be_a Springboard::Client::Response
+        expect(response).to be_a Springboard::Client::Response
       end
 
       it "should remove redundant base path prefix from URL if present" do
-        request_stub = stub_request(method, "#{base_url}/relative/path")
+        stub_request(method, "#{base_url}/relative/path")
         response = client.__send__(method, '/api/relative/path')
-        response.should be_a Springboard::Client::Response
+        expect(response).to be_a Springboard::Client::Response
       end
     end
 
     describe bang_method do
       it "should call #{method}" do
-        response = mock(Springboard::Client::Response)
-        response.should_receive(:success?).and_return(true)
-        client.should_receive(method).with('/path', false).and_return(response)
-        client.__send__(bang_method, '/path').should === response
+        response = double(Springboard::Client::Response)
+        expect(response).to receive(:success?).and_return(true)
+        expect(client).to receive(method).with('/path', false).and_return(response)
+        expect(client.__send__(bang_method, '/path')).to be === response
       end
 
       it "should raise an exception on failure" do
-        response = mock(Springboard::Client::Response)
-        response.should_receive(:success?).and_return(false)
-        response.should_receive(:status_line).and_return('404 Not Found')
-        client.should_receive(method).with('/path', false).and_return(response)
-        lambda { client.send(bang_method, '/path') }.should raise_error(Springboard::Client::RequestFailed)
+        response = double(Springboard::Client::Response)
+        expect(response).to receive(:success?).and_return(false)
+        expect(response).to receive(:status_line).and_return('404 Not Found')
+        expect(client).to receive(method).with('/path', false).and_return(response)
+        expect { client.send(bang_method, '/path') }.to raise_error(Springboard::Client::RequestFailed)
       end
     end
   end
@@ -121,19 +121,19 @@ describe Springboard::Client do
     bang_method = "#{method}!"
     describe method do
       it "should call session's #{method}" do
-        session.should_receive(method).with('/relative/path', 'body')
+        expect(session).to receive(method).with('/relative/path', 'body')
         client.__send__(method, '/relative/path', 'body')
       end
 
       it "should return a Springboard::Client::Response" do
-        request_stub = stub_request(method, "#{base_url}/relative/path")
+        stub_request(method, "#{base_url}/relative/path")
         response = client.__send__(method, '/relative/path', 'body')
-        response.should be_a Springboard::Client::Response
+        expect(response).to be_a Springboard::Client::Response
       end
 
       it "should serialize the request body as JSON if it is a hash" do
         body_hash = {:key1 => 'val1', :key2 => 'val2'}
-        session.should_receive(method).with('/path', body_hash.to_json)
+        expect(session).to receive(method).with('/path', body_hash.to_json)
         client.__send__(method, '/path', body_hash)
       end
 
@@ -141,33 +141,33 @@ describe Springboard::Client do
         request_stub = stub_request(method, "#{base_url}/my/resource").
           with(:headers => {'Content-Type' => 'application/json'})
         client.__send__(method, '/my/resource', :key1 => 'val1')
-        request_stub.should have_been_requested
+        expect(request_stub).to have_been_requested
       end
 
       it "should set the Content-Type header to specified value if specified" do
         request_stub = stub_request(method, "#{base_url}/my/resource").
           with(:headers => {'Content-Type' => 'application/pdf'})
         client.__send__(method, '/my/resource', {:key1 => 'val1'}, 'Content-Type' => 'application/pdf')
-        request_stub.should have_been_requested
+        expect(request_stub).to have_been_requested
       end
     end
 
     describe bang_method do
       it "should call #{method}" do
-        response = mock(Springboard::Client::Response)
-        response.should_receive(:success?).and_return(true)
-        client.should_receive(method).with('/path', 'body', false).and_return(response)
-        client.__send__(bang_method, '/path', 'body').should === response
+        response = double(Springboard::Client::Response)
+        expect(response).to receive(:success?).and_return(true)
+        expect(client).to receive(method).with('/path', 'body', false).and_return(response)
+        expect(client.__send__(bang_method, '/path', 'body')).to be === response
       end
 
       it "should raise an exception on failure" do
-        response = mock(Springboard::Client::Response)
-        response.should_receive(:success?).and_return(false)
-        response.should_receive(:status_line).and_return('404 Not Found')
-        client.should_receive(method).with('/path', 'body', false).and_return(response)
+        response = double(Springboard::Client::Response)
+        expect(response).to receive(:success?).and_return(false)
+        expect(response).to receive(:status_line).and_return('404 Not Found')
+        expect(client).to receive(method).with('/path', 'body', false).and_return(response)
         expect { client.send(bang_method, '/path', 'body') }.to raise_error { |error|
-          error.should be_a(Springboard::Client::RequestFailed)
-          error.response.should === response
+          expect(error).to be_a(Springboard::Client::RequestFailed)
+          expect(error.response).to be === response
         }
       end
     end
@@ -176,10 +176,10 @@ describe Springboard::Client do
   describe "each_page" do
     it "should request each page of the collection and yield each response to the block" do
       responses = (1..3).map do |p|
-        response = mock(Springboard::Client::Response)
-        response.stub(:[]).with('pages').and_return(3)
+        response = double(Springboard::Client::Response)
+        allow(response).to receive(:[]).with('pages').and_return(3)
 
-        client.should_receive(:get!).with("/things?page=#{p}&per_page=20".to_uri).and_return(response)
+        expect(client).to receive(:get!).with("/things?page=#{p}&per_page=20".to_uri).and_return(response)
 
         response
       end
@@ -193,15 +193,15 @@ describe Springboard::Client do
   describe "each" do
     it "should request each page of the collection and yield each individual result to the block" do
       all_results = (1..3).inject([]) do |results, p|
-        response = mock(Springboard::Client::Response)
-        response.stub(:[]).with('pages').and_return(3)
+        response = double(Springboard::Client::Response)
+        allow(response).to receive(:[]).with('pages').and_return(3)
 
         page_results = 20.times.map {|i| "Page #{p} result #{i+1}"}
         results += page_results
 
-        response.stub(:[]).with('results').and_return(page_results)
+        allow(response).to receive(:[]).with('results').and_return(page_results)
 
-        client.should_receive(:get!).with("/things?page=#{p}&per_page=20".to_uri).and_return(response)
+        expect(client).to receive(:get!).with("/things?page=#{p}&per_page=20".to_uri).and_return(response)
 
         results
       end

data/springboard-retail.gemspec

@@ -1,20 +1,18 @@
 Gem::Specification.new do |s|
-  s.name              = "springboard-retail"
-  s.version           = "4.0.0"
+  s.name              = 'springboard-retail'
+  s.version           = '4.0.1'
   s.platform          = Gem::Platform::RUBY
-  s.authors           = ["Jay Stotz"]
-  s.summary           = "Springboard Retail API client library"
+  s.authors           = ['Jay Stotz']
+  s.summary           = 'Springboard Retail API client library'
 
-  s.required_rubygems_version = ">= 1.3.6"
+  s.required_rubygems_version = '>= 1.3.6'
 
-  s.add_runtime_dependency 'patron', '>= 0.4.18'
-  s.add_runtime_dependency 'addressable', '>= 2.2.8'
+  s.add_runtime_dependency 'patron', '0.4.18'
+  s.add_runtime_dependency 'addressable', '~> 2.2.8'
   s.add_runtime_dependency 'json', '>= 1.7.4'
   s.add_runtime_dependency 'hashie'
 
   s.files         = `git ls-files`.split("\n")
-  
+
   s.require_path = 'lib'
 end
-
-

metadata

@@ -1,41 +1,41 @@
 --- !ruby/object:Gem::Specification
 name: springboard-retail
 version: !ruby/object:Gem::Version
-  version: 4.0.0
+  version: 4.0.1
 platform: ruby
 authors:
 - Jay Stotz
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-27 00:00:00.000000000 Z
+date: 2015-04-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: patron
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '='
       - !ruby/object:Gem::Version
         version: 0.4.18
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '='
       - !ruby/object:Gem::Version
         version: 0.4.18
 - !ruby/object:Gem::Dependency
   name: addressable
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 2.2.8
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 2.2.8
 - !ruby/object:Gem::Dependency
@@ -98,30 +98,34 @@ files:
 - spec/springboard/client_spec.rb
 - springboard-retail.gemspec
 - vendor/cache/addressable-2.2.8.gem
-- vendor/cache/coderay-1.0.7.gem
-- vendor/cache/coveralls-0.6.9.gem
-- vendor/cache/crack-0.3.1.gem
-- vendor/cache/diff-lcs-1.1.3.gem
-- vendor/cache/hashie-2.0.5.gem
-- vendor/cache/json-1.8.1.gem
-- vendor/cache/method_source-0.8.gem
-- vendor/cache/mime-types-1.25.gem
-- vendor/cache/multi_json-1.8.0.gem
+- vendor/cache/coderay-1.1.0.gem
+- vendor/cache/coveralls-0.7.11.gem
+- vendor/cache/crack-0.4.2.gem
+- vendor/cache/diff-lcs-1.2.5.gem
+- vendor/cache/docile-1.1.5.gem
+- vendor/cache/hashie-3.4.1.gem
+- vendor/cache/json-1.8.2.gem
+- vendor/cache/method_source-0.8.2.gem
+- vendor/cache/mime-types-2.4.3.gem
+- vendor/cache/multi_json-1.11.0.gem
+- vendor/cache/netrc-0.10.3.gem
 - vendor/cache/patron-0.4.18.gem
-- vendor/cache/pry-0.9.10.gem
-- vendor/cache/rake-0.9.2.2.gem
-- vendor/cache/rest-client-1.6.7.gem
-- vendor/cache/rspec-2.11.0.gem
-- vendor/cache/rspec-core-2.11.1.gem
-- vendor/cache/rspec-expectations-2.11.2.gem
-- vendor/cache/rspec-mocks-2.11.1.gem
-- vendor/cache/simplecov-0.7.1.gem
-- vendor/cache/simplecov-html-0.7.1.gem
-- vendor/cache/slop-3.3.2.gem
-- vendor/cache/term-ansicolor-1.2.2.gem
-- vendor/cache/thor-0.18.1.gem
-- vendor/cache/tins-0.9.0.gem
-- vendor/cache/webmock-1.8.8.gem
+- vendor/cache/pry-0.10.1.gem
+- vendor/cache/rake-10.4.2.gem
+- vendor/cache/rest-client-1.7.3.gem
+- vendor/cache/rspec-3.2.0.gem
+- vendor/cache/rspec-core-3.2.2.gem
+- vendor/cache/rspec-expectations-3.2.0.gem
+- vendor/cache/rspec-mocks-3.2.1.gem
+- vendor/cache/rspec-support-3.2.2.gem
+- vendor/cache/safe_yaml-1.0.4.gem
+- vendor/cache/simplecov-0.9.2.gem
+- vendor/cache/simplecov-html-0.9.0.gem
+- vendor/cache/slop-3.6.0.gem
+- vendor/cache/term-ansicolor-1.3.0.gem
+- vendor/cache/thor-0.19.1.gem
+- vendor/cache/tins-1.3.5.gem
+- vendor/cache/webmock-1.17.4.gem
 homepage: 
 licenses: []
 metadata: {}