her 0.8.2 → 0.8.3

data/.travis.yml

@@ -3,6 +3,7 @@ language: ruby
 sudo: false
 
 rvm:
+  - 2.3.1
   - 2.2.2
   - 2.1.6
   - 2.0.0

data/her.gemspec

@@ -18,9 +18,7 @@ Gem::Specification.new do |s|
   s.require_paths = ["lib"]
 
   s.add_development_dependency "rake", "~> 10.0"
-  s.add_development_dependency "rspec", "~> 2.13"
-  s.add_development_dependency "rspec-its", "~> 1.0"
-  s.add_development_dependency "fivemat", "~> 1.2"
+  s.add_development_dependency "rspec", "~> 3.5"
   s.add_development_dependency "json", "~> 1.8"
 
   s.add_runtime_dependency "activemodel", ">= 3.0.0", "<= 6.0.0"

data/lib/her/model/orm.rb

@@ -160,7 +160,10 @@ module Her
         #   # Called via DELETE "/users/1"
         def destroy_existing(id, params={})
           request(params.merge(:_method => method_for(:destroy), :_path => build_request_path(params.merge(primary_key => id)))) do |parsed_data, response|
-            new(parse(parsed_data[:data]).merge(:_destroyed => true))
+            data = parse(parsed_data[:data])
+            metadata = parsed_data[:metadata]
+            response_errors = parsed_data[:errors]
+            new(data.merge(:_destroyed => true, :metadata => metadata, :response_errors => response_errors))
           end
         end
 

data/lib/her/version.rb

@@ -1,3 +1,3 @@
 module Her
-  VERSION = "0.8.2"
+  VERSION = "0.8.3"
 end

data/spec/api_spec.rb

@@ -8,21 +8,24 @@ describe Her::API do
     describe "#setup" do
       context "when setting custom middleware" do
         before do
-          class Foo; end;
-          class Bar; end;
+          class Foo; end
+          class Bar; end
 
-          subject.setup :url => "https://api.example.com" do |connection|
+          subject.setup url: "https://api.example.com" do |connection|
             connection.use Foo
             connection.use Bar
           end
         end
 
-        specify { subject.connection.builder.handlers.should == [Foo, Bar] }
+        specify { expect(subject.connection.builder.handlers).to eq([Foo, Bar]) }
       end
 
       context "when setting custom options" do
-        before { subject.setup :foo => { :bar => "baz" }, :url => "https://api.example.com" }
-        its(:options) { should == { :foo => { :bar => "baz" }, :url => "https://api.example.com" } }
+        before { subject.setup foo: { bar: "baz" }, url: "https://api.example.com" }
+
+        describe "#options" do
+          it { expect(subject.options).to eq(foo: { bar: "baz" }, url: "https://api.example.com") }
+        end
       end
     end
 
@@ -30,83 +33,83 @@ describe Her::API do
       before do
         class SimpleParser < Faraday::Response::Middleware
           def on_complete(env)
-            env[:body] = { :data => env[:body] }
+            env[:body] = { data: env[:body] }
           end
         end
       end
 
       context "making HTTP requests" do
-        let(:parsed_data) { subject.request(:_method => :get, :_path => "/foo")[:parsed_data] }
+        let(:parsed_data) { subject.request(_method: :get, _path: "/foo")[:parsed_data] }
         before do
-          subject.setup :url => "https://api.example.com" do |builder|
+          subject.setup url: "https://api.example.com" do |builder|
             builder.use SimpleParser
-            builder.adapter(:test) { |stub| stub.get("/foo") { |env| [200, {}, "Foo, it is."] } }
+            builder.adapter(:test) { |stub| stub.get("/foo") { [200, {}, "Foo, it is."] } }
           end
         end
 
-        specify { parsed_data[:data].should == "Foo, it is." }
+        specify { expect(parsed_data[:data]).to eq("Foo, it is.") }
       end
 
       context "making HTTP requests while specifying custom HTTP headers" do
-        let(:parsed_data) { subject.request(:_method => :get, :_path => "/foo", :_headers => { "X-Page" => 2 })[:parsed_data] }
+        let(:parsed_data) { subject.request(_method: :get, _path: "/foo", _headers: { "X-Page" => 2 })[:parsed_data] }
 
         before do
-          subject.setup :url => "https://api.example.com" do |builder|
+          subject.setup url: "https://api.example.com" do |builder|
             builder.use SimpleParser
-            builder.adapter(:test) { |stub| stub.get("/foo") { |env| [200, {}, "Foo, it is page #{env[:request_headers]["X-Page"]}."] } }
+            builder.adapter(:test) { |stub| stub.get("/foo") { |env| [200, {}, "Foo, it is page #{env[:request_headers]['X-Page']}."] } }
           end
         end
 
-        specify { parsed_data[:data].should == "Foo, it is page 2." }
+        specify { expect(parsed_data[:data]).to eq("Foo, it is page 2.") }
       end
 
       context "parsing a request with the default parser" do
-        let(:parsed_data) { subject.request(:_method => :get, :_path => "users/1")[:parsed_data] }
+        let(:parsed_data) { subject.request(_method: :get, _path: "users/1")[:parsed_data] }
         before do
-          subject.setup :url => "https://api.example.com" do |builder|
+          subject.setup url: "https://api.example.com" do |builder|
             builder.use Her::Middleware::FirstLevelParseJSON
             builder.adapter :test do |stub|
-              stub.get("/users/1") { |env| [200, {}, MultiJson.dump({ :id => 1, :name => "George Michael Bluth", :errors => ["This is a single error"], :metadata => { :page => 1, :per_page => 10 } })] }
+              stub.get("/users/1") { [200, {}, MultiJson.dump(id: 1, name: "George Michael Bluth", errors: ["This is a single error"], metadata: { page: 1, per_page: 10 })] }
             end
           end
         end
 
         specify do
-          parsed_data[:data].should == { :id => 1, :name => "George Michael Bluth" }
-          parsed_data[:errors].should == ["This is a single error"]
-          parsed_data[:metadata].should == { :page => 1, :per_page => 10 }
+          expect(parsed_data[:data]).to eq(id: 1, name: "George Michael Bluth")
+          expect(parsed_data[:errors]).to eq(["This is a single error"])
+          expect(parsed_data[:metadata]).to eq(page: 1, per_page: 10)
         end
       end
 
       context "parsing a request with a custom parser" do
-        let(:parsed_data) { subject.request(:_method => :get, :_path => "users/1")[:parsed_data] }
+        let(:parsed_data) { subject.request(_method: :get, _path: "users/1")[:parsed_data] }
         before do
           class CustomParser < Faraday::Response::Middleware
             def on_complete(env)
-              json = MultiJson.load(env[:body], :symbolize_keys => true)
+              json = MultiJson.load(env[:body], symbolize_keys: true)
               errors = json.delete(:errors) || []
               metadata = json.delete(:metadata) || {}
               env[:body] = {
-                :data => json,
-                :errors => errors,
-                :metadata => metadata,
+                data: json,
+                errors: errors,
+                metadata: metadata
               }
             end
           end
 
-          subject.setup :url => "https://api.example.com" do |builder|
+          subject.setup url: "https://api.example.com" do |builder|
             builder.use CustomParser
             builder.use Faraday::Request::UrlEncoded
             builder.adapter :test do |stub|
-              stub.get("/users/1") { |env| [200, {}, MultiJson.dump(:id => 1, :name => "George Michael Bluth")] }
+              stub.get("/users/1") { [200, {}, MultiJson.dump(id: 1, name: "George Michael Bluth")] }
             end
           end
         end
 
         specify do
-          parsed_data[:data].should == { :id => 1, :name => "George Michael Bluth" }
-          parsed_data[:errors].should == []
-          parsed_data[:metadata].should == {}
+          expect(parsed_data[:data]).to eq(id: 1, name: "George Michael Bluth")
+          expect(parsed_data[:errors]).to eq([])
+          expect(parsed_data[:metadata]).to eq({})
         end
       end
     end

data/spec/collection_spec.rb

@@ -1,26 +1,41 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe Her::Collection do
-
   let(:items) { [1, 2, 3, 4] }
-  let(:metadata) { { :name => 'Testname' } }
-  let(:errors) { { :name => ['not_present'] } }
+  let(:metadata) { { name: "Testname" } }
+  let(:errors) { { name: ["not_present"] } }
 
   describe "#new" do
     context "without parameters" do
       subject { Her::Collection.new }
 
-      it { should eq([]) }
-      its(:metadata) { should eq({}) }
-      its(:errors) { should eq({}) }
+      it { is_expected.to eq([]) }
+
+      describe "#metadata" do
+        subject { super().metadata }
+        it { is_expected.to eq({}) }
+      end
+
+      describe "#errors" do
+        subject { super().errors }
+        it { is_expected.to eq({}) }
+      end
     end
 
     context "with parameters" do
       subject { Her::Collection.new(items, metadata, errors) }
 
-      it { should eq([1,2,3,4]) }
-      its(:metadata) { should eq({ :name => 'Testname' }) }
-      its(:errors) { should eq({ :name => ['not_present'] }) }
+      it { is_expected.to eq([1, 2, 3, 4]) }
+
+      describe "#metadata" do
+        subject { super().metadata }
+        it { is_expected.to eq(name: "Testname") }
+      end
+
+      describe "#errors" do
+        subject { super().errors }
+        it { is_expected.to eq(name: ["not_present"]) }
+      end
     end
   end
 end

data/spec/json_api/model_spec.rb

@@ -1,163 +1,166 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe Her::JsonApi::Model do
   before do
-    Her::API.setup :url => "https://api.example.com" do |connection|
+    Her::API.setup url: "https://api.example.com" do |connection|
       connection.use Her::Middleware::JsonApiParser
       connection.adapter :test do |stub|
-        stub.get("/users/1") do |env| 
-          [ 
+        stub.get("/users/1") do
+          [
             200,
             {},
             {
               data: {
                 id:    1,
-                type: 'users',
+                type: "users",
                 attributes: {
-                  name: "Roger Federer",
-                },
+                  name: "Roger Federer"
+                }
               }
-              
+
             }.to_json
-          ] 
+          ]
         end
 
-        stub.get("/users") do |env| 
-          [ 
+        stub.get("/users") do
+          [
             200,
             {},
             {
               data: [
                 {
                   id:    1,
-                  type: 'users',
+                  type: "users",
                   attributes: {
-                    name: "Roger Federer",
-                  },
-                }, 
+                    name: "Roger Federer"
+                  }
+                },
                 {
                   id:    2,
-                  type: 'users',
+                  type: "users",
                   attributes: {
-                    name: "Kei Nishikori",
-                  },
+                    name: "Kei Nishikori"
+                  }
                 }
               ]
             }.to_json
-          ] 
+          ]
         end
 
-        stub.post("/users", data: {
-          type: 'users',
+        stub.post("/users", data:
+        {
+          type: "users",
           attributes: {
-            name: "Jeremy Lin",
-          },
-        }) do |env|
-          [ 
+            name: "Jeremy Lin"
+          }
+        }) do
+          [
             201,
             {},
             {
               data: {
                 id:    3,
-                type: 'users',
+                type: "users",
                 attributes: {
-                  name: 'Jeremy Lin',
-                },
+                  name: "Jeremy Lin"
+                }
               }
-              
+
             }.to_json
-          ] 
+          ]
         end
 
-        stub.patch("/users/1", data: {
-          type: 'users',
+        stub.patch("/users/1", data:
+        {
+          type: "users",
           id: 1,
           attributes: {
-            name: "Fed GOAT",
-          },
-        }) do |env|
-          [ 
+            name: "Fed GOAT"
+          }
+        }) do
+          [
             200,
             {},
             {
               data: {
                 id:    1,
-                type: 'users',
+                type: "users",
                 attributes: {
-                  name: 'Fed GOAT',
-                },
+                  name: "Fed GOAT"
+                }
               }
-              
+
             }.to_json
-          ] 
+          ]
         end
 
-        stub.delete("/users/1") { |env|
-          [ 204, {}, {}, ] 
-        }
+        stub.delete("/users/1") do
+          [204, {}, {}]
+        end
       end
-
     end
 
     spawn_model("Foo::User", type: Her::JsonApi::Model)
   end
 
-  it 'allows configuration of type' do
+  it "allows configuration of type" do
     spawn_model("Foo::Bar", type: Her::JsonApi::Model) do
       type :foobars
     end
 
-    expect(Foo::Bar.instance_variable_get('@type')).to eql('foobars')
+    expect(Foo::Bar.instance_variable_get("@type")).to eql("foobars")
   end
 
-  it 'finds models by id' do
+  it "finds models by id" do
     user = Foo::User.find(1)
     expect(user.attributes).to eql(
-      'id' => 1,
-      'name' => 'Roger Federer',
+      "id" => 1,
+      "name" => "Roger Federer"
     )
   end
 
-  it 'finds a collection of models' do
+  it "finds a collection of models" do
     users = Foo::User.all
-    expect(users.map(&:attributes)).to match_array([
-      {
-        'id' => 1,
-        'name' => 'Roger Federer',
-      },
-      {
-        'id' => 2,
-        'name' => 'Kei Nishikori',
-      }
-    ])
+    expect(users.map(&:attributes)).to match_array(
+      [
+        {
+          "id" => 1,
+          "name" => "Roger Federer"
+        },
+        {
+          "id" => 2,
+          "name" => "Kei Nishikori"
+        }
+      ]
+    )
   end
 
-  it 'creates a Foo::User' do
-    user = Foo::User.new(name: 'Jeremy Lin')
+  it "creates a Foo::User" do
+    user = Foo::User.new(name: "Jeremy Lin")
     user.save
     expect(user.attributes).to eql(
-      'id' => 3,
-      'name' => 'Jeremy Lin',
+      "id" => 3,
+      "name" => "Jeremy Lin"
     )
   end
 
-  it 'updates a Foo::User' do
+  it "updates a Foo::User" do
     user = Foo::User.find(1)
-    user.name = 'Fed GOAT'
+    user.name = "Fed GOAT"
     user.save
     expect(user.attributes).to eql(
-      'id' => 1,
-      'name' => 'Fed GOAT',
+      "id" => 1,
+      "name" => "Fed GOAT"
     )
   end
 
-  it 'destroys a Foo::User' do
+  it "destroys a Foo::User" do
     user = Foo::User.find(1)
     expect(user.destroy).to be_destroyed
   end
 
-  context 'undefined methods' do
-    it 'removes methods that are not compatible with json api' do
+  context "undefined methods" do
+    it "removes methods that are not compatible with json api" do
       [:parse_root_in_json, :include_root_in_json, :root_element, :primary_key].each do |method|
         expect { Foo::User.new.send(method, :foo) }.to raise_error NoMethodError, "Her::JsonApi::Model does not support the #{method} configuration option"
       end