her 0.7.6 → 0.8.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1640cf3b6da7256158a07bd83d34cde38de4e3b7
-  data.tar.gz: f98a7292913c5227d8843e18220f4df6023f688d
+  metadata.gz: 606f0ea519a2ac25fd041636d9ef3294a26b406d
+  data.tar.gz: 86d7b4be4bdba0ce5e93b6410c53323478de6c7b
 SHA512:
-  metadata.gz: f509b4f473ea0fb74b7f4fa7ad939bb8b7ea9fa9b50d73847f56a5192878f3d3f2e96995b31ae20d5479e2c4603e9e5073d8ade4100248950fc96179e00f4ef3
-  data.tar.gz: 22874bb7b1a909f226e85821ab99d77b7b8cb79f6265b0699ba017497d3fde9753c54905aaabae41de95976e86b90ada01a7632251bc24b1d4b6fd3bea7c05bb
+  metadata.gz: 177aa0aa91c294a4300ce3aed89646499df76d5b82f3230a9ce4b0e46e037ad4c2086ddb60a31d9ebb502845c26e75b6fcce069f2fb4a7166f18a3b9a60c6e48
+  data.tar.gz: 293fdbad4a95fc6d3126b4292b2de8624495751e2e12f4c272a0070ac41d2d832b5842e2b263cc118fd50d84f893e9cd4e9b14f51ee45edf1757ef4a74a21659

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2012-2013 Rémi Prévost
+Copyright (c) 2012-2015 Rémi Prévost
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
 

data/README.md

@@ -586,20 +586,44 @@ users = Users.all
 
 #### JSON API support
 
-If the API returns data in the [JSON API format](http://jsonapi.org/) you need
-to configure Her as follows:
+To consume a JSON API 1.0 compliant service, it must return data in accordance with the [JSON API spec](http://jsonapi.org/). The general format
+of the data is as follows: 
+
+```json
+{ "data": {
+  "type": "developers",
+  "id": "6ab79c8c-ec5a-4426-ad38-8763bbede5a7",
+  "attributes": {
+    "language": "ruby",
+    "name": "avdi grimm",
+  }
+}
+```
+
+Then to setup your models:
 
 ```ruby
-class User
-  include Her::Model
-  parse_root_in_json true, format: :json_api
+class Contributor
+  include Her::JsonApi::Model
+
+  # defaults to demodulized, pluralized class name, e.g. contributors
+  type :developers
 end
+```
 
-user = Users.find(1)
-# GET "/users/1", response is { "users": [{ "id": 1, "fullname": "Lindsay Fünke" }] }
+Finally, you'll need to use the included JsonApiParser Her middleware:
 
-users = Users.all
-# GET "/users", response is { "users": [{ "id": 1, "fullname": "Lindsay Fünke" }, { "id": 2, "fullname": "Tobias Fünke" }] }
+```ruby
+Her::API.setup url: 'https://my_awesome_json_api_service' do |c|
+  # Request
+  c.use FaradayMiddleware::EncodeJson
+
+  # Response
+  c.use Her::Middleware::JsonApiParser
+
+  # Adapter
+  c.use Faraday::Adapter::NetHttp
+end
 ```
 
 ### Custom requests

data/UPGRADE.md

@@ -2,6 +2,14 @@
 
 Here is a list of notable changes by release. Her follows the [Semantic Versioning](http://semver.org/) system.
 
+## 0.8.0
+
+- Initial support for JSONAPI [link](https://github.com/remiprev/her/pull/347)
+- Fix for has_one association parsing [link](https://github.com/remiprev/her/pull/352)
+- Fix for escaping path variables HT @marshall-lee [link](https://github.com/remiprev/her/pull/354)
+- Fix syntax highlighting in README HT @tippenein [link](https://github.com/remiprev/her/pull/356)
+- Fix associations with Active Model Serializers HT @minktom [link](https://github.com/remiprev/her/pull/359)
+
 ## 0.7.6
 
 - Loosen restrictions on ActiveSupport and ActiveModel to accommodate security fixes [link](https://github.com/remiprev/her/commit/8ff641fcdaf14be7cc9b1a6ee6654f27f7dfa34c)

data/lib/her.rb

@@ -13,4 +13,7 @@ require "her/errors"
 require "her/collection"
 
 module Her
+  module JsonApi
+    autoload :Model, 'her/json_api/model'
+  end
 end

data/lib/her/api.rb

@@ -3,7 +3,7 @@ module Her
   # so it knows where to make those requests. In Rails, this is usually done in `config/initializers/her.rb`:
   class API
     # @private
-    attr_reader :base_uri, :connection, :options
+    attr_reader :connection, :options
 
     # Constants
     FARADAY_OPTIONS = [:request, :proxy, :ssl, :builder, :url, :parallel_manager, :params, :headers, :builder_class].freeze
@@ -70,7 +70,6 @@ module Her
     #   end
     def setup(opts={}, &blk)
       opts[:url] = opts.delete(:base_uri) if opts.include?(:base_uri) # Support legacy :base_uri option
-      @base_uri = opts[:url]
       @options = opts
 
       faraday_options = @options.reject { |key, value| !FARADAY_OPTIONS.include?(key.to_sym) }

data/lib/her/json_api/model.rb

@@ -0,0 +1,46 @@
+module Her
+  module JsonApi
+    module Model
+      
+      def self.included(klass)
+        klass.class_eval do
+          include Her::Model
+
+          [:parse_root_in_json, :include_root_in_json, :root_element, :primary_key].each do |method|
+            define_method method do |*args|
+              raise NoMethodError, "Her::JsonApi::Model does not support the #{method} configuration option"
+            end
+          end
+
+          method_for :update, :patch
+
+          @type = name.demodulize.tableize
+          
+          def self.parse(data)
+            data.fetch(:attributes).merge(data.slice(:id))
+          end
+
+          def self.to_params(attributes, changes={})
+            request_data = { type: @type }.tap { |request_body| 
+              attrs = attributes.dup.symbolize_keys.tap { |filtered_attributes|
+                if her_api.options[:send_only_modified_attributes]
+                  filtered_attributes = changes.symbolize_keys.keys.inject({}) do |hash, attribute|
+                    hash[attribute] = filtered_attributes[attribute]
+                    hash
+                  end
+                end
+              }
+              request_body[:id] = attrs.delete(:id) if attrs[:id]
+              request_body[:attributes] = attrs
+            }
+            { data: request_data }
+          end
+
+          def self.type(type_name)
+            @type = type_name.to_s
+          end
+        end
+      end
+    end
+  end
+end

data/lib/her/middleware.rb

@@ -6,5 +6,7 @@ require "her/middleware/accept_json"
 module Her
   module Middleware
     DefaultParseJSON = FirstLevelParseJSON
+
+    autoload :JsonApiParser,   'her/middleware/json_api_parser'
   end
 end

data/lib/her/middleware/json_api_parser.rb

@@ -0,0 +1,36 @@
+module Her
+  module Middleware
+    # This middleware expects the resource/collection data to be contained in the `data`
+    # key of the JSON object
+    class JsonApiParser < ParseJSON
+      # Parse the response body
+      #
+      # @param [String] body The response body
+      # @return [Mixed] the parsed response
+      # @private
+      def parse(body)
+        json = parse_json(body)
+
+        {
+          :data => json[:data] || {},
+          :errors => json[:errors] || [],
+          :metadata => json[:meta] || {},
+        }
+      end
+
+      # This method is triggered when the response has been received. It modifies
+      # the value of `env[:body]`.
+      #
+      # @param [Hash] env The response environment
+      # @private
+      def on_complete(env)
+        env[:body] = case env[:status]
+        when 204
+          parse('{}')
+        else
+          parse(env[:body])
+        end
+      end
+    end
+  end
+end

data/lib/her/model.rb

@@ -67,6 +67,9 @@ module Her
       # Configure ActiveModel callbacks
       extend ActiveModel::Callbacks
       define_model_callbacks :create, :update, :save, :find, :destroy, :initialize
+
+      # Define matchers for attr? and attr= methods
+      define_attribute_method_matchers
     end
   end
 end

data/lib/her/model/associations/association.rb

@@ -29,7 +29,7 @@ module Her
           if data[data_key].kind_of?(klass)
             { association[:name] => data[data_key] }
           else
-            { association[:name] => klass.new(data[data_key]) }
+            { association[:name] => klass.new(klass.parse(data[data_key])) }
           end
         end
 
@@ -94,7 +94,7 @@ module Her
         def find(id)
           return nil if id.blank?
           path = build_association_path lambda { "#{@parent.request_path(@params)}#{@opts[:path]}/#{id}" }
-          @klass.get(path, @params)
+          @klass.get_resource(path, @params)
         end
 
       end

data/lib/her/model/associations/belongs_to_association.rb

@@ -74,14 +74,14 @@ module Her
         def fetch
           foreign_key_value = @parent.attributes[@opts[:foreign_key].to_sym]
           data_key_value = @parent.attributes[@opts[:data_key].to_sym]
-          return @opts[:default].try(:dup) if (@parent.attributes.include?(@name) && @parent.attributes[@name].nil? && @params.empty?) || (@parent.persisted? && foreign_key_value.blank? && data_key_value.blank?)
+          return @opts[:default].try(:dup) if (@parent.attributes.include?(@name) && @parent.attributes[@name].nil? && @params.empty?) || (foreign_key_value.blank? && data_key_value.blank?)
 
           return @cached_result unless @params.any? || @cached_result.nil?
           return @parent.attributes[@name] unless @params.any? || @parent.attributes[@name].blank?
 
           path_params = @parent.attributes.merge(@params.merge(@klass.primary_key => foreign_key_value))
           path = build_association_path lambda { @klass.build_request_path(path_params) }
-          @klass.get(path, @params).tap do |result|
+          @klass.get_resource(path, @params).tap do |result|
             @cached_result = result if @params.blank?
           end
         end

data/lib/her/model/attributes.rb

@@ -158,6 +158,22 @@ module Her
         @attributes.hash
       end
 
+      # Assign attribute value (ActiveModel convention method).
+      #
+      # @private
+      def attribute=(attribute, value)
+        @attributes[attribute] = nil unless @attributes.include?(attribute)
+        self.send(:"#{attribute}_will_change!") if @attributes[attribute] != value
+        @attributes[attribute] = value
+      end
+
+      # Check attribute value to be present (ActiveModel convention method).
+      #
+      # @private
+      def attribute?(attribute)
+        @attributes.include?(attribute) && @attributes[attribute].present?
+      end
+
       module ClassMethods
         # Initialize a collection of resources with raw data from an HTTP request
         #
@@ -175,6 +191,25 @@ module Her
           new(parse(parsed_data[:data]).merge :_metadata => parsed_data[:metadata], :_errors => parsed_data[:errors])
         end
 
+        # Define attribute method matchers to automatically define them using ActiveModel's define_attribute_methods.
+        #
+        # @private
+        def define_attribute_method_matchers
+          attribute_method_suffix '='
+          attribute_method_suffix '?'
+        end
+
+        # Create a mutex for dynamically generated attribute methods or use one defined by ActiveModel.
+        #
+        # @private
+        def attribute_methods_mutex
+          @attribute_methods_mutex ||= if generated_attribute_methods.respond_to? :mu_synchronize
+                                         generated_attribute_methods
+                                       else
+                                         Mutex.new
+                                       end
+        end
+
         # Define the attributes that will be used to track dirty attributes and validations
         #
         # @param [Array] attributes
@@ -184,22 +219,8 @@ module Her
         #     attributes :name, :email
         #   end
         def attributes(*attributes)
-          define_attribute_methods attributes
-
-          attributes.each do |attribute|
-            unless method_defined?(:"#{attribute}=")
-              define_method("#{attribute}=") do |value|
-                @attributes[:"#{attribute}"] = nil unless @attributes.include?(:"#{attribute}")
-                self.send(:"#{attribute}_will_change!") if @attributes[:"#{attribute}"] != value
-                @attributes[:"#{attribute}"] = value
-              end
-            end
-
-            unless method_defined?(:"#{attribute}?")
-              define_method("#{attribute}?") do
-                @attributes.include?(:"#{attribute}") && @attributes[:"#{attribute}"].present?
-              end
-            end
+          attribute_methods_mutex.synchronize do
+            define_attribute_methods attributes
           end
         end
 

data/lib/her/model/orm.rb

@@ -8,6 +8,7 @@ module Her
       def new?
         id.nil?
       end
+      alias new_record? new?
 
       # Return `true` if a resource is not `#new?`
       def persisted?

data/lib/her/model/parse.rb

@@ -169,7 +169,7 @@ module Her
         #
         # @private
         def extract_array(request_data)
-          if active_model_serializers_format? || json_api_format?
+          if request_data[:data].is_a?(Hash) && (active_model_serializers_format? || json_api_format?)
             request_data[:data][pluralized_parsed_root_element]
           else
             request_data[:data]

data/lib/her/model/paths.rb

@@ -106,8 +106,13 @@ module Her
 
           path.gsub(/:([\w_]+)/) do
             # Look for :key or :_key, otherwise raise an exception
-            value = $1.to_sym
-            parameters.delete(value) || parameters.delete(:"_#{value}") || raise(Her::Errors::PathError.new("Missing :_#{$1} parameter to build the request path. Path is `#{path}`. Parameters are `#{parameters.symbolize_keys.inspect}`.", $1))
+            key = $1.to_sym
+            value = parameters.delete(key) || parameters.delete(:"_#{key}")
+            if value
+              Faraday::Utils.escape value
+            else
+              raise(Her::Errors::PathError.new("Missing :_#{$1} parameter to build the request path. Path is `#{path}`. Parameters are `#{parameters.symbolize_keys.inspect}`.", $1))
+            end
           end
         end
 

data/lib/her/version.rb

@@ -1,3 +1,3 @@
 module Her
-  VERSION = "0.7.6"
+  VERSION = "0.8.1"
 end

data/spec/api_spec.rb

@@ -5,24 +5,7 @@ describe Her::API do
   subject { Her::API.new }
 
   context "initialization" do
-    describe ".setup" do
-      it "creates a default connection" do
-        Her::API.setup :url => "https://api.example.com"
-        Her::API.default_api.base_uri.should == "https://api.example.com"
-      end
-    end
-
     describe "#setup" do
-      context "when using :url option" do
-        before { subject.setup :url => "https://api.example.com" }
-        its(:base_uri) { should == "https://api.example.com" }
-      end
-
-      context "when using the legacy :base_uri option" do
-        before { subject.setup :base_uri => "https://api.example.com" }
-        its(:base_uri) { should == "https://api.example.com" }
-      end
-
       context "when setting custom middleware" do
         before do
           class Foo; end;

data/spec/json_api/model_spec.rb

@@ -0,0 +1,166 @@
+require 'spec_helper'
+
+describe Her::JsonApi::Model do
+  before do
+    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| 
+          [ 
+            200,
+            {},
+            {
+              data: {
+                id:    1,
+                type: 'users',
+                attributes: {
+                  name: "Roger Federer",
+                },
+              }
+              
+            }.to_json
+          ] 
+        end
+
+        stub.get("/users") do |env| 
+          [ 
+            200,
+            {},
+            {
+              data: [
+                {
+                  id:    1,
+                  type: 'users',
+                  attributes: {
+                    name: "Roger Federer",
+                  },
+                }, 
+                {
+                  id:    2,
+                  type: 'users',
+                  attributes: {
+                    name: "Kei Nishikori",
+                  },
+                }
+              ]
+            }.to_json
+          ] 
+        end
+
+        stub.post("/users", data: {
+          type: 'users',
+          attributes: {
+            name: "Jeremy Lin",
+          },
+        }) do |env|
+          [ 
+            201,
+            {},
+            {
+              data: {
+                id:    3,
+                type: 'users',
+                attributes: {
+                  name: 'Jeremy Lin',
+                },
+              }
+              
+            }.to_json
+          ] 
+        end
+
+        stub.patch("/users/1", data: {
+          type: 'users',
+          id: 1,
+          attributes: {
+            name: "Fed GOAT",
+          },
+        }) do |env|
+          [ 
+            200,
+            {},
+            {
+              data: {
+                id:    1,
+                type: 'users',
+                attributes: {
+                  name: 'Fed GOAT',
+                },
+              }
+              
+            }.to_json
+          ] 
+        end
+
+        stub.delete("/users/1") { |env|
+          [ 204, {}, {}, ] 
+        }
+      end
+
+    end
+
+    spawn_model("Foo::User", type: Her::JsonApi::Model)
+  end
+
+  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')
+  end
+
+  it 'finds models by id' do
+    user = Foo::User.find(1)
+    expect(user.attributes).to eql(
+      'id' => 1,
+      'name' => 'Roger Federer',
+    )
+  end
+
+  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',
+      }
+    ])
+  end
+
+  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',
+    )
+  end
+
+  it 'updates a Foo::User' do
+    user = Foo::User.find(1)
+    user.name = 'Fed GOAT'
+    user.save
+    expect(user.attributes).to eql(
+      'id' => 1,
+      'name' => 'Fed GOAT',
+    )
+  end
+
+  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
+      [: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
+    end
+  end
+end

data/spec/middleware/json_api_parser_spec.rb

@@ -0,0 +1,32 @@
+# encoding: utf-8
+require "spec_helper"
+
+describe Her::Middleware::JsonApiParser do
+  subject { described_class.new }
+
+  context "with valid JSON body" do
+    let(:body) { '{"data": {"type": "foo", "id": "bar", "attributes": {"baz": "qux"} }, "meta": {"api": "json api"} }' }
+    let(:env) { { body: body } }
+
+    it "parses body as json" do
+      subject.on_complete(env)
+      env.fetch(:body).tap do |json|
+        expect(json[:data]).to eql(
+          :type => "foo",
+          :id => "bar",
+          :attributes => { :baz => "qux" } 
+        )
+        expect(json[:errors]).to eql([])
+        expect(json[:metadata]).to eql(:api => "json api")
+      end
+    end
+  end
+
+  #context "with invalid JSON body" do
+  #  let(:body) { '"foo"' }
+  #  it 'ensures that invalid JSON throws an exception' do
+  #    expect { subject.parse(body) }.to raise_error(Her::Errors::ParseError, 'Response from the API must behave like a Hash or an Array (last JSON response was "\"foo\"")')
+  #  end
+  #end
+
+end

data/spec/model/associations_spec.rb

@@ -76,7 +76,7 @@ describe Her::Model::Associations do
       describe "associations accessor" do
         subject { Class.new(Foo::User).associations }
         its(:object_id) { should_not eql Foo::User.associations.object_id }
-      its([:has_many]) { should eql [{ :name => :comments, :data_key => :comments, :default => [], :class_name => "Post", :path => "/comments", :inverse_of => nil }] }
+        its([:has_many]) { should eql [{ :name => :comments, :data_key => :comments, :default => [], :class_name => "Post", :path => "/comments", :inverse_of => nil }] }
       end
     end
   end
@@ -132,6 +132,7 @@ describe Her::Model::Associations do
 
       @user_with_included_data = Foo::User.find(1)
       @user_without_included_data = Foo::User.find(2)
+      @user_without_organization_and_not_persisted = Foo::User.new(organization_id: nil, name: "Katlin Fünke")
     end
 
     let(:user_with_included_data_after_create) { Foo::User.create }
@@ -210,6 +211,10 @@ describe Her::Model::Associations do
       @user_without_included_data.organization.name.should == "Bluth Company"
     end
 
+    it "returns nil if the foreign key is nil" do
+      @user_without_organization_and_not_persisted.organization.should be_nil
+    end
+
     it "fetches belongs_to data even if it was included, only if called with parameters" do
       @user_with_included_data.organization.where(:foo_id => 1).name.should == "Bluth Company Foo"
     end
@@ -231,6 +236,7 @@ describe Her::Model::Associations do
 
     it "fetches data with the specified id when calling find" do
       comment = @user_without_included_data.comments.find(5)
+      comment.should be_a(Foo::Comment)
       comment.id.should eq(5)
     end
 
@@ -265,6 +271,88 @@ describe Her::Model::Associations do
     end
   end
 
+  context "handling associations with details in active_model_serializers format" do
+    before do
+      Her::API.setup :url => "https://api.example.com" do |builder|
+        builder.use Her::Middleware::FirstLevelParseJSON
+        builder.use Faraday::Request::UrlEncoded
+        builder.adapter :test do |stub|
+          stub.get("/users/1") { |env| [200, {}, { :user => { :id => 1, :name => "Tobias Fünke", :comments => [{ :id => 2, :body => "Tobias, you blow hard!", :user_id => 1 }, { :id => 3, :body => "I wouldn't mind kissing that man between the cheeks, so to speak", :user_id => 1 }], :role => { :id => 1, :body => "Admin" }, :organization => { :id => 1, :name => "Bluth Company" }, :organization_id => 1 } }.to_json] }
+          stub.get("/users/2") { |env| [200, {}, { :user => { :id => 2, :name => "Lindsay Fünke", :organization_id => 1 } }.to_json] }
+          stub.get("/users/1/comments") { |env| [200, {}, { :comments => [{ :id => 4, :body => "They're having a FIRESALE?" }] }.to_json] }
+          stub.get("/users/2/comments") { |env| [200, {}, { :comments => [{ :id => 4, :body => "They're having a FIRESALE?" }, { :id => 5, :body => "Is this the tiny town from Footloose?" }] }.to_json] }
+          stub.get("/users/2/comments/5") { |env| [200, {}, { :comment => { :id => 5, :body => "Is this the tiny town from Footloose?" } }.to_json] }
+          stub.get("/organizations/1") { |env| [200, {}, { :organization =>  { :id => 1, :name => "Bluth Company Foo" } }.to_json] }
+        end
+      end
+      spawn_model "Foo::User" do
+        parse_root_in_json true, :format => :active_model_serializers
+        has_many :comments, class_name: "Foo::Comment"
+        belongs_to :organization
+      end
+      spawn_model "Foo::Comment" do
+        belongs_to :user
+        parse_root_in_json true, :format => :active_model_serializers
+      end
+      spawn_model "Foo::Organization" do
+        parse_root_in_json true, :format => :active_model_serializers
+      end
+
+      @user_with_included_data = Foo::User.find(1)
+      @user_without_included_data = Foo::User.find(2)
+    end
+
+    it "maps an array of included data through has_many" do
+      @user_with_included_data.comments.first.should be_a(Foo::Comment)
+      @user_with_included_data.comments.length.should == 2
+      @user_with_included_data.comments.first.id.should == 2
+      @user_with_included_data.comments.first.body.should == "Tobias, you blow hard!"
+    end
+
+    it "does not refetch the parents models data if they have been fetched before" do
+      @user_with_included_data.comments.first.user.object_id.should == @user_with_included_data.object_id
+    end
+
+    it "fetches data that was not included through has_many" do
+      @user_without_included_data.comments.first.should be_a(Foo::Comment)
+      @user_without_included_data.comments.length.should == 2
+      @user_without_included_data.comments.first.id.should == 4
+      @user_without_included_data.comments.first.body.should == "They're having a FIRESALE?"
+    end
+
+    it "fetches has_many data even if it was included, only if called with parameters" do
+      @user_with_included_data.comments.where(:foo_id => 1).length.should == 1
+    end
+
+    it "maps an array of included data through belongs_to" do
+      @user_with_included_data.organization.should be_a(Foo::Organization)
+      @user_with_included_data.organization.id.should == 1
+      @user_with_included_data.organization.name.should == "Bluth Company"
+    end
+
+    it "fetches data that was not included through belongs_to" do
+      @user_without_included_data.organization.should be_a(Foo::Organization)
+      @user_without_included_data.organization.id.should == 1
+      @user_without_included_data.organization.name.should == "Bluth Company Foo"
+    end
+
+    it "fetches belongs_to data even if it was included, only if called with parameters" do
+      @user_with_included_data.organization.where(:foo_id => 1).name.should == "Bluth Company Foo"
+    end
+
+    it "fetches data with the specified id when calling find" do
+      comment = @user_without_included_data.comments.find(5)
+      comment.should be_a(Foo::Comment)
+      comment.id.should eq(5)
+    end
+
+    it 'includes has_many relationships in params by default' do
+      params = @user_with_included_data.to_params
+      params[:comments].should be_kind_of(Array)
+      params[:comments].length.should eq(2)
+    end
+  end
+
   context "handling associations with details" do
     before do
       Her::API.setup :url => "https://api.example.com" do |builder|

data/spec/model/attributes_spec.rb

@@ -299,5 +299,91 @@ describe Her::Model::Attributes do
       user.assign_attributes(fullname: 'Tobias Fünke')
       user.fullname?.should be_truthy
     end
+
+    context "when attribute methods are already defined" do
+      before do
+        class AbstractUser
+          attr_accessor :fullname
+
+          def fullname?
+            @fullname.present?
+          end
+        end
+        @spawned_models << :AbstractUser
+
+        spawn_model 'Foo::User', super_class: AbstractUser do
+          attributes :fullname
+        end
+      end
+
+      it "overrides getter method" do
+        Foo::User.generated_attribute_methods.instance_methods.should include(:fullname)
+      end
+
+      it "overrides setter method" do
+        Foo::User.generated_attribute_methods.instance_methods.should include(:fullname=)
+      end
+
+      it "overrides predicate method" do
+        Foo::User.generated_attribute_methods.instance_methods.should include(:fullname?)
+      end
+
+      it "defines setter that affects @attributes" do
+        user = Foo::User.new
+        user.fullname = 'Tobias Fünke'
+        user.attributes[:fullname].should eq('Tobias Fünke')
+      end
+
+      it "defines getter that reads @attributes" do
+        user = Foo::User.new
+        user.attributes[:fullname] = 'Tobias Fünke'
+        user.fullname.should eq('Tobias Fünke')
+      end
+
+      it "defines predicate that reads @attributes" do
+        user = Foo::User.new
+        user.fullname?.should be_falsey
+        user.attributes[:fullname] = 'Tobias Fünke'
+        user.fullname?.should be_truthy
+      end
+    end
+
+    if ActiveModel::VERSION::MAJOR < 4
+      it "creates a new mutex" do
+        expect(Mutex).to receive(:new).once.and_call_original
+        spawn_model 'Foo::User' do
+          attributes :fullname
+        end
+        Foo::User.attribute_methods_mutex.should_not eq(Foo::User.generated_attribute_methods)
+      end
+
+      it "works well with Module#synchronize monkey patched by ActiveSupport" do
+        Module.class_eval do
+          def synchronize(*args)
+            raise 'gotcha!'
+          end
+        end
+        expect(Mutex).to receive(:new).once.and_call_original
+        spawn_model 'Foo::User' do
+          attributes :fullname
+        end
+        Foo::User.attribute_methods_mutex.should_not eq(Foo::User.generated_attribute_methods)
+        Module.class_eval do
+          undef :synchronize
+        end
+      end
+    else
+      it "uses ActiveModel's mutex" do
+        Foo::User.attribute_methods_mutex.should eq(Foo::User.generated_attribute_methods)
+      end
+    end
+
+    it "uses a mutex" do
+      spawn_model 'Foo::User'
+      expect(Foo::User.attribute_methods_mutex).to receive(:synchronize).once.and_call_original
+      Foo::User.class_eval do
+        attributes :fullname, :documents
+      end
+    end
   end
 end

data/spec/model/http_spec.rb

@@ -12,42 +12,6 @@ describe Her::Model::HTTP do
       Her::API.setup :url => "https://api.example.com"
     end
 
-    context "when binding a model to an instance of Her::API" do
-      before { Foo::User.uses_api api1 }
-      subject { Foo::User.her_api }
-      its(:base_uri) { should == "https://api1.example.com" }
-    end
-
-    context "when binding a model directly to Her::API" do
-      before { spawn_model "Foo::User" }
-      subject { Foo::User.her_api }
-      its(:base_uri) { should == "https://api.example.com" }
-    end
-
-    context "when using a proc for uses_api" do
-      before do
-        Foo::User.uses_api lambda { Her::API.new :url => 'http://api-lambda.example.com' }
-      end
-
-      specify { Foo::User.her_api.base_uri.should == 'http://api-lambda.example.com' }
-    end
-
-    context "when binding two models to two different instances of Her::API" do
-      before do
-        Foo::User.uses_api api1
-        Foo::Comment.uses_api api2
-      end
-
-      specify { Foo::User.her_api.base_uri.should == "https://api1.example.com" }
-      specify { Foo::Comment.her_api.base_uri.should == "https://api2.example.com" }
-    end
-
-    context "binding one model to Her::API and another one to an instance of Her::API" do
-      before { Foo::Comment.uses_api api2 }
-      specify { Foo::User.her_api.base_uri.should == "https://api.example.com" }
-      specify { Foo::Comment.her_api.base_uri.should == "https://api2.example.com" }
-    end
-
     context "when binding a model to its superclass' her_api" do
       before do
         spawn_model "Foo::Superclass"

data/spec/model/orm_spec.rb

@@ -49,10 +49,12 @@ describe Her::Model::ORM do
     it "handles new resource" do
       @new_user = Foo::User.new(:fullname => "Tobias Fünke")
       @new_user.new?.should be_truthy
+      @new_user.new_record?.should be_truthy
       @new_user.fullname.should == "Tobias Fünke"
 
       @existing_user = Foo::User.find(1)
       @existing_user.new?.should be_falsey
+      @existing_user.new_record?.should be_falsey
     end
 
     it 'handles new resource with custom primary key' do

data/spec/model/paths_spec.rb

@@ -8,60 +8,66 @@ describe Her::Model::Paths do
         spawn_model "Foo::User"
       end
 
-      describe "#build_request_path" do
+      describe "#request_path" do
         it "builds paths with defaults" do
-          Foo::User.build_request_path(:id => "foo").should == "users/foo"
-          Foo::User.build_request_path(:id => nil).should == "users"
-          Foo::User.build_request_path.should == "users"
+          Foo::User.new(:id => "foo").request_path.should == "users/foo"
+          Foo::User.new(:id => nil).request_path.should == "users"
+          Foo::User.new().request_path.should == "users"
         end
 
         it "builds paths with custom collection path" do
           Foo::User.collection_path "/utilisateurs"
-          Foo::User.build_request_path(:id => "foo").should == "/utilisateurs/foo"
-          Foo::User.build_request_path.should == "/utilisateurs"
+          Foo::User.new(:id => "foo").request_path.should == "/utilisateurs/foo"
+          Foo::User.new().request_path.should == "/utilisateurs"
         end
 
         it "builds paths with custom relative collection path" do
           Foo::User.collection_path "utilisateurs"
-          Foo::User.build_request_path(:id => "foo").should == "utilisateurs/foo"
-          Foo::User.build_request_path.should == "utilisateurs"
+          Foo::User.new(:id => "foo").request_path.should == "utilisateurs/foo"
+          Foo::User.new().request_path.should == "utilisateurs"
         end
 
         it "builds paths with custom collection path with multiple variables" do
           Foo::User.collection_path "/organizations/:organization_id/utilisateurs"
 
-          Foo::User.build_request_path(:id => "foo", :_organization_id => "acme").should == "/organizations/acme/utilisateurs/foo"
-          Foo::User.build_request_path(:_organization_id => "acme").should == "/organizations/acme/utilisateurs"
+          Foo::User.new(:id => "foo").request_path(:_organization_id => "acme").should == "/organizations/acme/utilisateurs/foo"
+          Foo::User.new().request_path(:_organization_id => "acme").should == "/organizations/acme/utilisateurs"
 
-          Foo::User.build_request_path(:id => "foo", :organization_id => "acme").should == "/organizations/acme/utilisateurs/foo"
-          Foo::User.build_request_path(:organization_id => "acme").should == "/organizations/acme/utilisateurs"
+          Foo::User.new(:id => "foo", :organization_id => "acme").request_path.should == "/organizations/acme/utilisateurs/foo"
+          Foo::User.new(:organization_id => "acme").request_path.should == "/organizations/acme/utilisateurs"
         end
 
         it "builds paths with custom relative collection path with multiple variables" do
           Foo::User.collection_path "organizations/:organization_id/utilisateurs"
 
-          Foo::User.build_request_path(:id => "foo", :_organization_id => "acme").should == "organizations/acme/utilisateurs/foo"
-          Foo::User.build_request_path(:_organization_id => "acme").should == "organizations/acme/utilisateurs"
+          Foo::User.new(:id => "foo").request_path(:_organization_id => "acme").should == "organizations/acme/utilisateurs/foo"
+          Foo::User.new().request_path(:_organization_id => "acme").should == "organizations/acme/utilisateurs"
 
-          Foo::User.build_request_path(:id => "foo", :organization_id => "acme").should == "organizations/acme/utilisateurs/foo"
-          Foo::User.build_request_path(:organization_id => "acme").should == "organizations/acme/utilisateurs"
+          Foo::User.new(:id => "foo", :organization_id => "acme").request_path.should == "organizations/acme/utilisateurs/foo"
+          Foo::User.new(:organization_id => "acme").request_path.should == "organizations/acme/utilisateurs"
         end
 
         it "builds paths with custom item path" do
           Foo::User.resource_path "/utilisateurs/:id"
-          Foo::User.build_request_path(:id => "foo").should == "/utilisateurs/foo"
-          Foo::User.build_request_path.should == "users"
+          Foo::User.new(:id => "foo").request_path.should == "/utilisateurs/foo"
+          Foo::User.new().request_path.should == "users"
         end
 
         it "builds paths with custom relative item path" do
           Foo::User.resource_path "utilisateurs/:id"
-          Foo::User.build_request_path(:id => "foo").should == "utilisateurs/foo"
-          Foo::User.build_request_path.should == "users"
+          Foo::User.new(:id => "foo").request_path.should == "utilisateurs/foo"
+          Foo::User.new().request_path.should == "users"
         end
 
         it "raises exceptions when building a path without required custom variables" do
           Foo::User.collection_path "/organizations/:organization_id/utilisateurs"
-          expect { Foo::User.build_request_path(:id => "foo") }.to raise_error(Her::Errors::PathError, "Missing :_organization_id parameter to build the request path. Path is `/organizations/:organization_id/utilisateurs/:id`. Parameters are `{:id=>\"foo\"}`.")
+          expect { Foo::User.new(:id => "foo").request_path }.to raise_error(Her::Errors::PathError, "Missing :_organization_id parameter to build the request path. Path is `/organizations/:organization_id/utilisateurs/:id`. Parameters are `{:id=>\"foo\"}`.")
+        end
+
+        it "escapes the variable values" do
+          Foo::User.collection_path "organizations/:organization_id/utilisateurs"
+          Foo::User.new(:id => "Привет").request_path(:_organization_id => 'лол').should == "organizations/%D0%BB%D0%BE%D0%BB/utilisateurs/%D0%9F%D1%80%D0%B8%D0%B2%D0%B5%D1%82"
+          Foo::User.new(:organization_id => 'лол', :id => "Привет").request_path.should == "organizations/%D0%BB%D0%BE%D0%BB/utilisateurs/%D0%9F%D1%80%D0%B8%D0%B2%D0%B5%D1%82"
         end
       end
     end
@@ -71,56 +77,56 @@ describe Her::Model::Paths do
         spawn_model "Foo::AdminUser"
       end
 
-      describe "#build_request_path" do
+      describe "#request_path" do
         it "builds paths with defaults" do
-          Foo::AdminUser.build_request_path(:id => "foo").should == "admin_users/foo"
-          Foo::AdminUser.build_request_path.should == "admin_users"
+          Foo::AdminUser.new(:id => "foo").request_path.should == "admin_users/foo"
+          Foo::AdminUser.new().request_path.should == "admin_users"
         end
 
         it "builds paths with custom collection path" do
           Foo::AdminUser.collection_path "/users"
-          Foo::AdminUser.build_request_path(:id => "foo").should == "/users/foo"
-          Foo::AdminUser.build_request_path.should == "/users"
+          Foo::AdminUser.new(:id => "foo").request_path.should == "/users/foo"
+          Foo::AdminUser.new().request_path.should == "/users"
         end
 
         it "builds paths with custom relative collection path" do
           Foo::AdminUser.collection_path "users"
-          Foo::AdminUser.build_request_path(:id => "foo").should == "users/foo"
-          Foo::AdminUser.build_request_path.should == "users"
+          Foo::AdminUser.new(:id => "foo").request_path.should == "users/foo"
+          Foo::AdminUser.new().request_path.should == "users"
         end
 
         it "builds paths with custom collection path with multiple variables" do
           Foo::AdminUser.collection_path "/organizations/:organization_id/users"
-          Foo::AdminUser.build_request_path(:id => "foo", :_organization_id => "acme").should == "/organizations/acme/users/foo"
-          Foo::AdminUser.build_request_path(:_organization_id => "acme").should == "/organizations/acme/users"
+          Foo::AdminUser.new(:id => "foo").request_path(:_organization_id => "acme").should == "/organizations/acme/users/foo"
+          Foo::AdminUser.new().request_path(:_organization_id => "acme").should == "/organizations/acme/users"
         end
 
         it "builds paths with custom relative collection path with multiple variables" do
           Foo::AdminUser.collection_path "organizations/:organization_id/users"
-          Foo::AdminUser.build_request_path(:id => "foo", :_organization_id => "acme").should == "organizations/acme/users/foo"
-          Foo::AdminUser.build_request_path(:_organization_id => "acme").should == "organizations/acme/users"
+          Foo::AdminUser.new(:id => "foo").request_path(:_organization_id => "acme").should == "organizations/acme/users/foo"
+          Foo::AdminUser.new().request_path(:_organization_id => "acme").should == "organizations/acme/users"
         end
 
         it "builds paths with custom item path" do
           Foo::AdminUser.resource_path "/users/:id"
-          Foo::AdminUser.build_request_path(:id => "foo").should == "/users/foo"
-          Foo::AdminUser.build_request_path.should == "admin_users"
+          Foo::AdminUser.new(:id => "foo").request_path.should == "/users/foo"
+          Foo::AdminUser.new().request_path.should == "admin_users"
         end
 
         it "builds paths with custom relative item path" do
           Foo::AdminUser.resource_path "users/:id"
-          Foo::AdminUser.build_request_path(:id => "foo").should == "users/foo"
-          Foo::AdminUser.build_request_path.should == "admin_users"
+          Foo::AdminUser.new(:id => "foo").request_path.should == "users/foo"
+          Foo::AdminUser.new().request_path.should == "admin_users"
         end
 
         it "raises exceptions when building a path without required custom variables" do
           Foo::AdminUser.collection_path "/organizations/:organization_id/users"
-          expect { Foo::AdminUser.build_request_path(:id => "foo") }.to raise_error(Her::Errors::PathError, "Missing :_organization_id parameter to build the request path. Path is `/organizations/:organization_id/users/:id`. Parameters are `{:id=>\"foo\"}`.")
+          expect { Foo::AdminUser.new(:id => "foo").request_path }.to raise_error(Her::Errors::PathError, "Missing :_organization_id parameter to build the request path. Path is `/organizations/:organization_id/users/:id`. Parameters are `{:id=>\"foo\"}`.")
         end
 
         it "raises exceptions when building a relative path without required custom variables" do
           Foo::AdminUser.collection_path "organizations/:organization_id/users"
-          expect { Foo::AdminUser.build_request_path(:id => "foo") }.to raise_error(Her::Errors::PathError, "Missing :_organization_id parameter to build the request path. Path is `organizations/:organization_id/users/:id`. Parameters are `{:id=>\"foo\"}`.")
+          expect { Foo::AdminUser.new(:id => "foo").request_path }.to raise_error(Her::Errors::PathError, "Missing :_organization_id parameter to build the request path. Path is `organizations/:organization_id/users/:id`. Parameters are `{:id=>\"foo\"}`.")
         end
       end
     end
@@ -152,10 +158,10 @@ describe Her::Model::Paths do
         spawn_model "Foo::User"
       end
 
-      describe "#build_request_path" do
+      describe "#request_path" do
         it "builds paths with defaults" do
-          Foo::User.build_request_path(:id => "foo").should == "users/foo"
-          Foo::User.build_request_path.should == "users"
+          Foo::User.new(:id => "foo").request_path.should == "users/foo"
+          Foo::User.new.request_path.should == "users"
         end
       end
     end
@@ -173,15 +179,15 @@ describe Her::Model::Paths do
         end
       end
 
-      describe '#build_request_path' do
+      describe '#request_path' do
         it 'uses the correct primary key attribute' do
-          User.build_request_path(:UserId => 'foo').should == 'users/foo'
-          User.build_request_path(:id => 'foo').should == 'users'
+          User.new(:UserId => 'foo').request_path.should == 'users/foo'
+          User.new(:id => 'foo').request_path.should == 'users'
         end
 
         it 'replaces :id with the appropriate primary key' do
-          Customer.build_request_path(:customer_id => 'joe').should == 'customers/joe'
-          Customer.build_request_path(:id => 'joe').should == 'customers'
+          Customer.new(:customer_id => 'joe').request_path.should == 'customers/joe'
+          Customer.new(:id => 'joe').request_path.should == 'customers'
         end
       end
     end

data/spec/support/macros/model_macros.rb

@@ -3,21 +3,28 @@ module Her
     module Macros
       module ModelMacros
         # Create a class and automatically inject Her::Model into it
-        def spawn_model(klass, &block)
+        def spawn_model(klass, options={}, &block)
+          super_class = options[:super_class]
+          model_type = options[:type] || Her::Model
+          new_class = if super_class
+                        Class.new(super_class)
+                      else
+                        Class.new
+                      end
           if klass =~ /::/
             base, submodel = klass.split(/::/).map{ |s| s.to_sym }
             Object.const_set(base, Module.new) unless Object.const_defined?(base)
             Object.const_get(base).module_eval do
               remove_const submodel if constants.map(&:to_sym).include?(submodel)
-              submodel = const_set(submodel, Class.new)
-              submodel.send(:include, Her::Model)
+              submodel = const_set(submodel, new_class)
+              submodel.send(:include, model_type)
               submodel.class_eval(&block) if block_given?
             end
 
             @spawned_models << base
           else
             Object.instance_eval { remove_const klass } if Object.const_defined?(klass)
-            Object.const_set(klass, Class.new).send(:include, Her::Model)
+            Object.const_set(klass, Class.new).send(:include, model_type)
             Object.const_get(klass).class_eval(&block) if block_given?
 
             @spawned_models << klass.to_sym

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: her
 version: !ruby/object:Gem::Version
-  version: 0.7.6
+  version: 0.8.1
 platform: ruby
 authors:
 - Rémi Prévost
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-06-16 00:00:00.000000000 Z
+date: 2015-09-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -180,9 +180,11 @@ files:
 - lib/her/api.rb
 - lib/her/collection.rb
 - lib/her/errors.rb
+- lib/her/json_api/model.rb
 - lib/her/middleware.rb
 - lib/her/middleware/accept_json.rb
 - lib/her/middleware/first_level_parse_json.rb
+- lib/her/middleware/json_api_parser.rb
 - lib/her/middleware/parse_json.rb
 - lib/her/middleware/second_level_parse_json.rb
 - lib/her/model.rb
@@ -205,8 +207,10 @@ files:
 - lib/her/version.rb
 - spec/api_spec.rb
 - spec/collection_spec.rb
+- spec/json_api/model_spec.rb
 - spec/middleware/accept_json_spec.rb
 - spec/middleware/first_level_parse_json_spec.rb
+- spec/middleware/json_api_parser_spec.rb
 - spec/middleware/second_level_parse_json_spec.rb
 - spec/model/associations/association_proxy_spec.rb
 - spec/model/associations_spec.rb
@@ -256,8 +260,10 @@ summary: A simple Representational State Transfer-based Hypertext Transfer Proto
 test_files:
 - spec/api_spec.rb
 - spec/collection_spec.rb
+- spec/json_api/model_spec.rb
 - spec/middleware/accept_json_spec.rb
 - spec/middleware/first_level_parse_json_spec.rb
+- spec/middleware/json_api_parser_spec.rb
 - spec/middleware/second_level_parse_json_spec.rb
 - spec/model/associations/association_proxy_spec.rb
 - spec/model/associations_spec.rb