her 0.5.1 → 0.5.2

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    MmZjNzAyYWJjNWQyZmJmZDQxNDgwYTgyMTU0MTViZjRiY2U2NmM5OQ==
+    NDM1MWIwOWZmYThlZjA5YTJlMzdlZDM3MDQzMjg5ZGNlOTVhOGYxMQ==
   data.tar.gz: !binary |-
-    Mzk1MjM1MTZhNDcyMTNlY2I2OTMzZTljOTU1NWJmMmU5MTE4Yjg3NQ==
+    ODgwMDMwMDM3M2MyZTdjN2YwZDBhMDlhMDJlZTY5MzcwZTVhMjVjNQ==
 !binary "U0hBNTEy":
   metadata.gz: !binary |-
-    OWI4ZWFhZDljMDNhMjgzYWVkNTQ5NDVhZmMzMjhmN2JhMTdiNDNlZjVkZjc4
-    NjNmNDRjMDg3MmJiMTg1YThiN2YzNTMwMTBhMGQxMGYxMGMzZWFhZmQ2MjU2
-    N2YwMDhlZjg1NTU2NzI5YTc0NmUzNWZhNTBmOTdhY2NiNDg1N2E=
+    OGIyY2JkM2Y5OTI4NzdmZDk5OTE2ZGM4OWU4ZTM3MTYzOWNhMGRlOWZlNTc4
+    ZTcxODBmYzMxYjdmNDJkNGFhZDc0NGQzZGE3ODU0NTE4ODliYjQ4MTIyMGJi
+    NjBjMTE3ZGE1ZDM5Y2QwYWVjNTgwZDQxOGRkNDc0OTRhYzA2YjQ=
   data.tar.gz: !binary |-
-    ZDY3NzU2MmFhZTJjN2I3MWQ1ODgzNGYyZTAwMDZhNTlhYTdmYTNkMjNjOWFi
-    MjMzMjliMjMxNWY1NGRlNzBmZDMxYTQ1YjIwMjgzOTg5NGRkM2MzNzhjNDRk
-    ZmJiYzdmZWE4YjA0ZGJmMTIxOTc3ZjNkMmUyMmI2NGZkODRhYzY=
+    M2ZlYmU3ZGE5ZjBkNDkxYjgyZWFlZmM4OWEyYjMxYzYzMmI1ODAyOTFhMmM1
+    ZDk0ZDA1YWUxODY2NGIzZDEwMTdiODQ5MWJkN2NlYjFlMTc5YjAxZmVkYzY1
+    NjY3YWY4NGIyNGFkNzMxNmZmY2E2YmJkOTIyNWZjMjU3MjZhNTE=

data/Gemfile

@@ -1,2 +1,2 @@
-source :rubygems
+source "https://rubygems.org"
 gemspec

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2012 Rémi Prévost
+Copyright (c) 2012-2013 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

@@ -261,12 +261,12 @@ end
 
 Here’s a list of several useful features available in Her.
 
-### Relationships
+### Associations
 
-You can define `has_many`, `has_one` and `belongs_to` relationships in your models. The relationship data is handled in two different ways.
+You can define `has_many`, `has_one` and `belongs_to` associations in your models. The association data is handled in two different ways.
 
-1. If Her finds relationship data when parsing a resource, that data will be used to create the associated model objects on the resource.
-2. If no relationship data was included when parsing a resource, calling a method with the same name as the relationship will fetch the data (providing there’s an HTTP request available for it in the API).
+1. If Her finds association data when parsing a resource, that data will be used to create the associated model objects on the resource.
+2. If no association data was included when parsing a resource, calling a method with the same name as the association will fetch the data (providing there’s an HTTP request available for it in the API).
 
 For example:
 
@@ -291,7 +291,7 @@ class Organization
 end
 ```
 
-If there’s relationship data in the resource, no extra HTTP request is made when calling the `#comments` method and an array of resources is returned:
+If there’s association data in the resource, no extra HTTP request is made when calling the `#comments` method and an array of resources is returned:
 
 ```ruby
 @user = User.find(1)
@@ -315,23 +315,23 @@ If there’s relationship data in the resource, no extra HTTP request is made wh
 # #<Organization id=2 name="Bluth Company">
 ```
 
-If there’s no relationship data in the resource, Her makes a HTTP request to retrieve the data.
+If there’s no association data in the resource, Her makes a HTTP request to retrieve the data.
 
 ```ruby
 @user = User.find(1)
 # { :data => { :id => 1, :name => "George Michael Bluth", :organization_id => 2 }}
 
-# has_many relationship:
+# has_many association:
 @user.comments
 # GET /users/1/comments
 # [#<Comment id=1>, #<Comment id=2>]
 
-# has_one relationship:
+# has_one association:
 @user.role
 # GET /users/1/role
 # #<Role id=1>
 
-# belongs_to relationship:
+# belongs_to association:
 @user.organization
 # (the organization id comes from :organization_id, by default)
 # GET /organizations/2
@@ -365,7 +365,6 @@ end
 ### Dirty attributes
 
 Her includes `ActiveModel::Dirty` so you can keep track of the attributes that have changed in an object.
-an object, or `#create` on a model class.
 
 ```ruby
 class User

data/lib/her/api.rb

@@ -7,8 +7,8 @@ module Her
 
     # Setup a default API connection. Accepted arguments and options are the same as {API#setup}.
     def self.setup(attrs={}, &block)
-      @@default_api = new
-      @@default_api.setup(attrs, &block)
+      @default_api = new
+      @default_api.setup(attrs, &block)
     end
 
     # Create a new API object. This is useful to create multiple APIs and use them with the `uses_api` method.
@@ -103,7 +103,7 @@ module Her
     private
     # @private
     def self.default_api(attrs={})
-      defined?(@@default_api) ? @@default_api : nil
+      defined?(@default_api) ? @default_api : nil
     end
   end
 end

data/lib/her/errors.rb

@@ -1,6 +1,6 @@
 module Her
   module Errors
     class PathError < StandardError; end;
-    class RelationshipUnknownError < StandardError; end;
+    class AssociationUnknownError < StandardError; end;
   end
 end

data/lib/her/model.rb

@@ -1,7 +1,7 @@
 require "her/model/base"
 require "her/model/http"
 require "her/model/orm"
-require "her/model/relationships"
+require "her/model/associations"
 require "her/model/introspection"
 require "her/model/paths"
 require "her/model/nested_attributes"
@@ -25,7 +25,7 @@ module Her
     include Her::Model::ORM
     include Her::Model::Introspection
     include Her::Model::Paths
-    include Her::Model::Relationships
+    include Her::Model::Associations
     include Her::Model::NestedAttributes
     include ActiveModel::Validations
     include ActiveModel::Conversion
@@ -51,18 +51,18 @@ module Her
 
     # Returns true if attribute_name is
     # * in orm data
-    # * a relationship
+    # * an association
     def has_key?(attribute_name)
       has_data?(attribute_name) ||
-      has_relationship?(attribute_name)
+      has_association?(attribute_name)
     end
 
     # Returns
     # * the value of the attribute_nane attribute if it's in orm data
-    # * the resource/collection corrsponding to attribute_name if it's a relationship
+    # * the resource/collection corrsponding to attribute_name if it's an association
     def [](attribute_name)
       get_data(attribute_name) ||
-      get_relationship(attribute_name)
+      get_association(attribute_name)
     end
   end
 end

data/lib/her/model/{relationships.rb → associations.rb}

@@ -1,49 +1,55 @@
 module Her
   module Model
-    # This module adds relationships to models
-    module Relationships
+    # This module adds associations to models
+    module Associations
       extend ActiveSupport::Concern
 
-      # Returns true if the model has a relationship_name relationship, false otherwise.
-      def has_relationship?(relationship_name)
-        relationships = self.class.relationships.values.flatten.map { |r| r[:name] }
-        relationships.include?(relationship_name)
+      # Returns true if the model has a association_name association, false otherwise.
+      def has_association?(association_name)
+        associations = self.class.associations.values.flatten.map { |r| r[:name] }
+        associations.include?(association_name)
       end
+      alias :has_relationship? :has_association?
 
-      # Returns the resource/collection corresponding to the relationship_name relationship.
-      def get_relationship(relationship_name)
-        send(relationship_name) if has_relationship?(relationship_name)
+      # Returns the resource/collection corresponding to the association_name association.
+      def get_association(association_name)
+        send(association_name) if has_association?(association_name)
       end
+      alias :get_relationship :get_association
 
       module ClassMethods
-        # Return @her_relationships, lazily initialized with copy of the
-        # superclass' her_relationships, or an empty hash.
+        # Return @her_associations, lazily initialized with copy of the
+        # superclass' her_associations, or an empty hash.
         #
         # @private
-        def relationships
-          @her_relationships ||= begin
-            if superclass.respond_to?(:relationships)
-              superclass.relationships.dup
+        def associations
+          @her_associations ||= begin
+            if superclass.respond_to?(:associations)
+              superclass.associations.dup
             else
               {}
             end
           end
         end
+        alias :relationships :associations
 
-        # Parse relationships data after initializing a new object
+        # Parse associations data after initializing a new object
         #
         # @private
-        def parse_relationships(data)
-          relationships.each_pair do |type, definitions|
-            definitions.each do |relationship|
-              name = relationship[:name]
-              next unless data[name]
-              klass = self.nearby_class(relationship[:class_name])
+        def parse_associations(data)
+          associations.each_pair do |type, definitions|
+            definitions.each do |association|
+              data_key = association[:data_key]
+              next unless data[data_key]
+
+              klass = self.nearby_class(association[:class_name])
+              name = association[:name]
+
               data[name] = case type
                 when :has_many
-                  Her::Model::ORM.initialize_collection(klass, :data => data[name])
+                  Her::Model::ORM.initialize_collection(klass, :data => data[data_key])
                 when :has_one, :belongs_to
-                  klass.new(klass.parse(data[name]))
+                  klass.new(data[data_key])
                 else
                   nil
               end
@@ -52,7 +58,7 @@ module Her
           data
         end
 
-        # Define an *has_many* relationship.
+        # Define an *has_many* association.
         #
         # @param [Symbol] name The name of the model
         # @param [Hash] attrs Options (currently not used)
@@ -74,34 +80,39 @@ module Her
           attrs = {
             :class_name     => name.to_s.classify,
             :name           => name,
+            :data_key       => name,
             :path           => "/#{name}",
             :inverse_of => nil
           }.merge(attrs)
-          (relationships[:has_many] ||= []) << attrs
+          (associations[:has_many] ||= []) << attrs
 
           define_method(name) do |*method_attrs|
             method_attrs = method_attrs[0] || {}
             klass = self.class.nearby_class(attrs[:class_name])
-            if method_attrs.any?
-              @data[name] = klass.get_collection("#{self.class.build_request_path(method_attrs.merge(:id => id))}#{attrs[:path]}", method_attrs)
-            else
-              @data[name] ||= klass.get_collection("#{self.class.build_request_path(:id => id)}#{attrs[:path]}")
+
+            return Her::Collection.new if @attributes.include?(name) && @attributes[name].empty? && method_attrs.empty?
+
+            if @attributes[name].blank? || method_attrs.any?
+              path = begin
+                self.class.build_request_path(@attributes.merge(method_attrs))
+              rescue Her::Errors::PathError
+                return nil
+              end
+
+              @attributes[name] = klass.get_collection("#{path}#{attrs[:path]}", method_attrs)
             end
 
-            inverse_of = if attrs[:inverse_of]
-                               attrs[:inverse_of]
-                            else
-                             self.class.name.split('::').last.tableize.singularize
-                           end
-            @data[name].each do |entry|
+            inverse_of = attrs[:inverse_of] || self.class.name.split('::').last.tableize.singularize
+
+            @attributes[name].each do |entry|
               entry.send("#{inverse_of}=", self)
             end
 
-            @data[name]
+            @attributes[name]
           end
         end
 
-        # Define an *has_one* relationship.
+        # Define an *has_one* association.
         #
         # @param [Symbol] name The name of the model
         # @param [Hash] attrs Options (currently not used)
@@ -123,22 +134,32 @@ module Her
           attrs = {
             :class_name => name.to_s.classify,
             :name => name,
+            :data_key => name,
             :path => "/#{name}"
           }.merge(attrs)
-          (relationships[:has_one] ||= []) << attrs
+          (associations[:has_one] ||= []) << attrs
 
           define_method(name) do |*method_attrs|
             method_attrs = method_attrs[0] || {}
             klass = self.class.nearby_class(attrs[:class_name])
-            if method_attrs.any?
-              klass.get_resource("#{self.class.build_request_path(method_attrs.merge(:id => id))}#{attrs[:path]}", method_attrs)
-            else
-              @data[name] ||= klass.get_resource("#{self.class.build_request_path(:id => id)}#{attrs[:path]}")
+
+            return nil if @attributes.include?(name) && @attributes[name].nil? && method_attrs.empty?
+
+            if @attributes[name].blank? || method_attrs.any?
+              path = begin
+                self.class.build_request_path(@attributes.merge(method_attrs))
+              rescue Her::Errors::PathError
+                return nil
+              end
+
+              @attributes[name] = klass.get_resource("#{path}#{attrs[:path]}", method_attrs)
             end
+
+            @attributes[name]
           end
         end
 
-        # Define a *belongs_to* relationship.
+        # Define a *belongs_to* association.
         #
         # @param [Symbol] name The name of the model
         # @param [Hash] attrs Options (currently not used)
@@ -160,29 +181,29 @@ module Her
           attrs = {
             :class_name => name.to_s.classify,
             :name => name,
+            :data_key => name,
             :foreign_key => "#{name}_id",
             :path => "/#{name.to_s.pluralize}/:id"
           }.merge(attrs)
-          (relationships[:belongs_to] ||= []) << attrs
+          (associations[:belongs_to] ||= []) << attrs
 
           define_method(name) do |*method_attrs|
             method_attrs = method_attrs[0] || {}
             klass = self.class.nearby_class(attrs[:class_name])
-            if method_attrs.any?
-              klass.get_resource("#{klass.build_request_path(method_attrs.merge(:id => @data[attrs[:foreign_key].to_sym]))}", method_attrs)
-            else
-              @data[name] ||= klass.get_resource("#{klass.build_request_path(:id => @data[attrs[:foreign_key].to_sym])}")
+
+            return nil if @attributes.include?(name) && @attributes[name].nil? && method_attrs.empty?
+
+            if @attributes[name].blank? || method_attrs.any?
+              path = begin
+                klass.build_request_path(@attributes.merge(method_attrs.merge(:id => @attributes[attrs[:foreign_key].to_sym])))
+              rescue Her::Errors::PathError
+                return nil
+              end
+
+              @attributes[name] = klass.get_resource("#{path}", method_attrs)
             end
-          end
-        end
 
-        # @private
-        def relationship_accessor(type, attrs)
-          name = attrs[:name]
-          class_name = attrs[:class_name]
-          define_method(name) do
-            klass = self.class.nearby_class(attrs[:class_name])
-            @data[name] ||= klass.get_resource("#{klass.build_request_path(attrs[:path], :id => @data[attrs[:foreign_key].to_sym])}")
+            @attributes[name]
           end
         end
       end

data/lib/her/model/introspection.rb

@@ -12,7 +12,7 @@ module Her
       #   @user = User.find(1)
       #   p @user # => #<User(/users/1) id=1 name="Tobias Fünke">
       def inspect
-        "#<#{self.class}(#{request_path}) #{@data.keys.map { |k| "#{k}=#{attribute_for_inspect(send(k))}" }.join(" ")}>"
+        "#<#{self.class}(#{request_path}) #{attributes.keys.map { |k| "#{k}=#{attribute_for_inspect(send(k))}" }.join(" ")}>"
       end
 
       private

data/lib/her/model/nested_attributes.rb

@@ -4,52 +4,52 @@ module Her
       extend ActiveSupport::Concern
 
       module ClassMethods
-        def accepts_nested_attributes_for(*relationship_names)
-          relationship_names.each do |relationship_name|
+        def accepts_nested_attributes_for(*association_names)
+          association_names.each do |association_name|
             type = nil
-            [:belongs_to, :has_one, :has_many].each do |relation_type|
-              if !relationships[relation_type].nil? && relationships[relation_type].any? { |relation| relation[:name] == relationship_name }
-                type = relation_type
+            [:belongs_to, :has_one, :has_many].each do |association_type|
+              if !associations[association_type].nil? && associations[association_type].any? { |association| association[:name] == association_name }
+                type = association_type
               end
             end
             if type.nil?
-              raise(RelationshipUnknownError.new("Unknown relationship name :#{relationship_name}"))
+              raise(AssociationUnknownError.new("Unknown association name :#{association_name}"))
             end
             class_eval <<-eoruby, __FILE__, __LINE__ + 1
-              if method_defined?(:#{relationship_name}_attributes=)
-                remove_method(:#{relationship_name}_attributes=)
+              if method_defined?(:#{association_name}_attributes=)
+                remove_method(:#{association_name}_attributes=)
               end
-              def #{relationship_name}_attributes=(attributes)
-                assign_nested_attributes_for_#{type}_relationship(:#{relationship_name}, attributes)
+              def #{association_name}_attributes=(attributes)
+                assign_nested_attributes_for_#{type}_association(:#{association_name}, attributes)
               end
             eoruby
           end
         end
       end
 
-      def assign_nested_attributes_for_belongs_to_relationship(relationship_name, attributes)
-        assign_nested_attributes_for_simple_relationship(:belongs_to, relationship_name, attributes)
+      def assign_nested_attributes_for_belongs_to_association(association_name, attributes)
+        assign_nested_attributes_for_simple_association(:belongs_to, association_name, attributes)
       end
 
-      def assign_nested_attributes_for_has_one_relationship(relationship_name, attributes)
-        assign_nested_attributes_for_simple_relationship(:has_one, relationship_name, attributes)
+      def assign_nested_attributes_for_has_one_association(association_name, attributes)
+        assign_nested_attributes_for_simple_association(:has_one, association_name, attributes)
       end
 
-      def assign_nested_attributes_for_has_many_relationship(relationship_name, attributes)
-        relationship = self.class.relationships[:has_many].find { |relation| relation[:name] == relationship_name }
-        klass = self.class.nearby_class(relationship[:class_name])
-        self.send("#{relationship[:name]}=", Her::Model::ORM.initialize_collection(klass, :data => attributes))
+      def assign_nested_attributes_for_has_many_association(association_name, attributes)
+        association = self.class.associations[:has_many].find { |association| association[:name] == association_name }
+        klass = self.class.nearby_class(association[:class_name])
+        self.send("#{association[:name]}=", Her::Model::ORM.initialize_collection(klass, :data => attributes))
       end
 
       private
-      def assign_nested_attributes_for_simple_relationship(relationship_type, relationship_name, attributes)
-        relationship = self.class.relationships[relationship_type].find { |relation| relation[:name] == relationship_name }
-        if has_data?(relationship[:name])
-          self.send("#{relationship[:name]}").assign_data(attributes)
+      def assign_nested_attributes_for_simple_association(association_type, association_name, attributes)
+        association = self.class.associations[association_type].find { |association| association[:name] == association_name }
+        if has_data?(association[:name])
+          self.send("#{association[:name]}").assign_data(attributes)
         else
-          klass = self.class.nearby_class(relationship[:class_name])
+          klass = self.class.nearby_class(association[:class_name])
           instance = klass.new(klass.parse(attributes))
-          self.send("#{relationship[:name]}=", instance)
+          self.send("#{association[:name]}=", instance)
         end
       end
     end

data/lib/her/model/orm.rb

@@ -3,17 +3,18 @@ module Her
     # This module adds ORM-like capabilities to the model
     module ORM
       extend ActiveSupport::Concern
-      attr_accessor :data, :metadata, :response_errors
-      alias :attributes :data
-      alias :attributes= :data=
+      attr_accessor :attributes, :metadata, :response_errors
+      alias :data :attributes
+      alias :data= :attributes=
 
       # Initialize a new object with data received from an HTTP request
-      def initialize(params={})
-        @metadata = params.delete(:_metadata) || {}
-        @response_errors = params.delete(:_errors) || {}
-        @destroyed = params.delete(:_destroyed) || false
+      def initialize(attributes={})
+        attributes ||= {}
+        @metadata = attributes.delete(:_metadata) || {}
+        @response_errors = attributes.delete(:_errors) || {}
+        @destroyed = attributes.delete(:_destroyed) || false
 
-        update_data(params)
+        update_attributes(attributes)
       end
 
       # Initialize a collection of resources
@@ -32,6 +33,7 @@ module Her
       # @private
       def self.use_setter_methods(model, params)
         setter_method_names = model.class.setter_method_names
+        params ||= {}
         params.inject({}) do |memo, (key, value)|
           setter_method = key.to_s + '='
           if setter_method_names.include?(setter_method)
@@ -46,16 +48,18 @@ module Her
         end
       end
 
-      # Handles missing methods by routing them through @data
+      # Handles missing methods
       # @private
       def method_missing(method, *args, &blk)
-        if method.to_s.end_with?('=')
-          attribute = method.to_s.chomp('=').to_sym
-          @data[attribute] = args.first
-        elsif method.to_s.end_with?('?')
-          @data.include?(method.to_s.chomp('?').to_sym)
-        elsif @data.include?(method)
-          @data[method]
+        if method.to_s =~ /[?=]$/ || attributes.include?(method)
+          # Extract the attribute
+          attribute = method.to_s.sub(/[?=]$/, '')
+
+          # Create a new `attribute` methods set
+          self.class.attributes(*attribute)
+
+          # Resend the method!
+          send(method, *args, &blk)
         else
           super
         end
@@ -63,44 +67,45 @@ module Her
 
       # Handles returning true for the cases handled by method_missing
       def respond_to?(method, include_private = false)
-        method.to_s.end_with?('=') || method.to_s.end_with?('?') || @data.include?(method) || super
+        method.to_s.end_with?('=') || method.to_s.end_with?('?') || @attributes.include?(method) || super
       end
 
       def respond_to_missing?(method, include_private = false)
-        method.to_s.end_with?('=') || method.to_s.end_with?('?') || @data.include?(method) || @data.include?(method) || super
+        method.to_s.end_with?('=') || method.to_s.end_with?('?') || @attributes.include?(method) || @attributes.include?(method) || super
       end
 
       # Assign new data to an instance
-      def assign_data(new_data)
-        new_data = Her::Model::ORM.use_setter_methods(self, new_data)
-        @data.update new_data
+      def assign_attributes(new_attributes)
+        new_attributes = Her::Model::ORM.use_setter_methods(self, new_attributes)
+        attributes.update new_attributes
       end
-      alias :assign_attributes :assign_data
+      alias :assign_data :assign_attributes
 
       # Handles returning true for the accessible attributes
-      def has_data?(attribute_name)
-        @data.include?(attribute_name)
+      def has_attribute?(attribute_name)
+        attributes.include?(attribute_name)
       end
+      alias :has_data? :has_attribute?
 
-      # Handles returning attribute value from data
-      def get_data(attribute_name)
-        @data[attribute_name]
+      def get_attribute(attribute_name)
+        attributes[attribute_name]
       end
+      alias :get_data :get_attribute
 
       # Override the method to prevent from returning the object ID (in ruby-1.8.7)
       # @private
       def id
-        @data[:id] || super
+        attributes[:id] || super
       end
 
       # Return `true` if a resource was not saved yet
       def new?
-        !@data.include?(:id)
+        !attributes.include?(:id)
       end
 
       # Return `true` if the other object is also a Her::Model and has matching data
       def ==(other)
-        other.is_a?(Her::Model) && @data == other.data
+        other.is_a?(Her::Model) && attributes == other.attributes
       end
 
       # Delegate to the == method
@@ -108,10 +113,10 @@ module Her
         self == other
       end
 
-      # Delegate to @data, allowing models to act correctly in code like:
+      # Delegate to @attributes, allowing models to act correctly in code like:
       #     [ Model.find(1), Model.find(1) ].uniq # => [ Model.find(1) ]
       def hash
-        @data.hash
+        attributes.hash
       end
 
       # Return whether the object has been destroyed
@@ -136,7 +141,7 @@ module Her
         params = to_params
         resource = self
 
-        if @data[:id]
+        if attributes[:id]
           callback = :update
           method = :put
         else
@@ -147,12 +152,12 @@ module Her
         run_callbacks callback do
           run_callbacks :save do
             self.class.request(params.merge(:_method => method, :_path => "#{request_path}")) do |parsed_data, response|
-              update_data(self.class.parse(parsed_data[:data])) if parsed_data[:data].any?
+              update_attributes(self.class.parse(parsed_data[:data])) if parsed_data[:data].any?
               self.metadata = parsed_data[:metadata]
               self.response_errors = parsed_data[:errors]
               self.changed_attributes.clear if self.changed_attributes.present?
 
-              return false if self.response_errors.any?
+              return false if !response.success? || self.response_errors.any?
             end
           end
         end
@@ -170,7 +175,7 @@ module Her
         resource = self
         run_callbacks :destroy do
           self.class.request(:_method => :delete, :_path => "#{request_path}") do |parsed_data, response|
-            update_data(self.class.parse(parsed_data[:data])) if parsed_data[:data].any?
+            update_attributes(self.class.parse(parsed_data[:data])) if parsed_data[:data].any?
             self.metadata = parsed_data[:metadata]
             self.response_errors = parsed_data[:errors]
             @destroyed = true
@@ -180,13 +185,13 @@ module Her
       end
 
       # @private
-      def update_data(raw_data)
-        @data ||= {}
-        # Use setter methods first, then translate attributes of relationships
-        # into relationship instances, then merge the parsed_data into @data.
-        unset_data = Her::Model::ORM.use_setter_methods(self, raw_data)
-        parsed_data = self.class.parse_relationships(unset_data)
-        @data.update(parsed_data)
+      def update_attributes(raw_data)
+        @attributes ||= {}
+        # Use setter methods first, then translate attributes of associations
+        # into association instances, then merge the parsed_data into @attributes.
+        unset_attributes = Her::Model::ORM.use_setter_methods(self, raw_data)
+        parsed_attributes = self.class.parse_associations(unset_attributes)
+        attributes.update(parsed_attributes)
       end
 
       # Convert into a hash of request parameters
@@ -196,9 +201,9 @@ module Her
       #   # => { :id => 1, :name => 'John Smith' }
       def to_params
         if self.class.include_root_in_json
-          { (self.class.include_root_in_json == true ? self.class.root_element : self.class.include_root_in_json) => @data.dup }
+          { (self.class.include_root_in_json == true ? self.class.root_element : self.class.include_root_in_json) => attributes.dup }
         else
-          @data.dup
+          attributes.dup
         end
       end
 
@@ -220,16 +225,16 @@ module Her
             attribute = attribute.to_sym
 
             define_method "#{attribute}".to_sym do
-              @data.include?(attribute) ? @data[attribute] : nil
+              @attributes.include?(attribute) ? @attributes[attribute] : nil
             end
 
             define_method "#{attribute}=".to_sym do |value|
-              self.send("#{attribute}_will_change!".to_sym) if @data[attribute] != value
-              @data[attribute] = value
+              self.send("#{attribute}_will_change!".to_sym) if @attributes[attribute] != value
+              @attributes[attribute] = value
             end
 
             define_method "#{attribute}?".to_sym do
-              @data.include?(attribute)
+              @attributes.include?(attribute) && @attributes[attribute].present?
             end
           end
         end
@@ -299,7 +304,7 @@ module Her
               request(params.merge(:_method => :post, :_path => "#{build_request_path(params)}")) do |parsed_data, response|
                 data = parse(parsed_data[:data])
                 resource.instance_eval do
-                  update_data(data)
+                  update_attributes(data)
                   @metadata = parsed_data[:metadata]
                   @response_errors = parsed_data[:errors]
                   @changed_attributes.clear if @changed_attributes.present?

data/lib/her/model/paths.rb

@@ -12,7 +12,7 @@ module Her
       #
       #   User.find(1) # Fetched via GET /utilisateurs/1
       def request_path
-        self.class.build_request_path(@data.dup)
+        self.class.build_request_path(attributes.dup)
       end
 
       module ClassMethods
@@ -67,7 +67,7 @@ module Her
 
           path.gsub(/:([\w_]+)/) do
             # Look for :key or :_key, otherwise raise an exception
-            parameters.delete($1.to_sym) || parameters.delete("_#{$1}".to_sym) || raise(Her::Errors::PathError.new("Missing :_#{$1} parameter to build the request path (#{path})."))
+            parameters.delete($1.to_sym) || parameters.delete("_#{$1}".to_sym) || raise(Her::Errors::PathError, "Missing :_#{$1} parameter to build the request path. Path is `#{path}`. Parameters are `#{parameters.inspect}`.")
           end
         end
 

data/lib/her/version.rb

@@ -1,3 +1,3 @@
 module Her
-  VERSION = "0.5.1"
+  VERSION = "0.5.2"
 end

data/spec/model/{relationships_spec.rb → associations_spec.rb}

@@ -1,100 +1,100 @@
 # encoding: utf-8
 require File.join(File.dirname(__FILE__), "../spec_helper.rb")
 
-describe Her::Model::Relationships do
-  context "setting relationships without details" do
+describe Her::Model::Associations do
+  context "setting associations without details" do
     before do
       spawn_model "Foo::User"
     end
 
-    it "handles a single 'has_many' relationship" do
+    it "handles a single 'has_many' association" do
       Foo::User.has_many :comments
-      Foo::User.relationships[:has_many].should == [{ :name => :comments, :class_name => "Comment", :path => "/comments", :inverse_of => nil }]
+      Foo::User.associations[:has_many].should == [{ :name => :comments, :data_key => :comments, :class_name => "Comment", :path => "/comments", :inverse_of => nil }]
     end
 
-    it "handles multiples 'has_many' relationship" do
+    it "handles multiples 'has_many' association" do
       Foo::User.has_many :comments
       Foo::User.has_many :posts
-      Foo::User.relationships[:has_many].should == [{ :name => :comments, :class_name => "Comment", :path => "/comments", :inverse_of => nil }, { :name => :posts, :class_name => "Post", :path => "/posts", :inverse_of => nil }]
+      Foo::User.associations[:has_many].should == [{ :name => :comments, :data_key => :comments, :class_name => "Comment", :path => "/comments", :inverse_of => nil }, { :name => :posts, :data_key => :posts, :class_name => "Post", :path => "/posts", :inverse_of => nil }]
     end
 
-    it "handles a single 'has_one' relationship" do
+    it "handles a single 'has_one' association" do
       Foo::User.has_one :category
-      Foo::User.relationships[:has_one].should == [{ :name => :category, :class_name => "Category", :path => "/category" }]
+      Foo::User.associations[:has_one].should == [{ :name => :category, :data_key => :category, :class_name => "Category", :path => "/category" }]
     end
 
-    it "handles multiples 'has_one' relationship" do
+    it "handles multiples 'has_one' association" do
       Foo::User.has_one :category
       Foo::User.has_one :role
-      Foo::User.relationships[:has_one].should == [{ :name => :category, :class_name => "Category", :path => "/category" }, { :name => :role, :class_name => "Role", :path => "/role" }]
+      Foo::User.associations[:has_one].should == [{ :name => :category, :data_key => :category, :class_name => "Category", :path => "/category" }, { :name => :role, :data_key => :role, :class_name => "Role", :path => "/role" }]
     end
 
-    it "handles a single belongs_to relationship" do
+    it "handles a single belongs_to association" do
       Foo::User.belongs_to :organization
-      Foo::User.relationships[:belongs_to].should == [{ :name => :organization, :class_name => "Organization", :foreign_key => "organization_id", :path => "/organizations/:id" }]
+      Foo::User.associations[:belongs_to].should == [{ :name => :organization, :data_key => :organization, :class_name => "Organization", :foreign_key => "organization_id", :path => "/organizations/:id" }]
     end
 
-    it "handles multiples 'belongs_to' relationship" do
+    it "handles multiples 'belongs_to' association" do
       Foo::User.belongs_to :organization
       Foo::User.belongs_to :family
-      Foo::User.relationships[:belongs_to].should == [{ :name => :organization, :class_name => "Organization", :foreign_key => "organization_id", :path => "/organizations/:id" }, { :name => :family, :class_name => "Family", :foreign_key => "family_id", :path => "/families/:id" }]
+      Foo::User.associations[:belongs_to].should == [{ :name => :organization, :data_key => :organization, :class_name => "Organization", :foreign_key => "organization_id", :path => "/organizations/:id" }, { :name => :family, :data_key => :family, :class_name => "Family", :foreign_key => "family_id", :path => "/families/:id" }]
     end
   end
 
-  context "setting relationships with details" do
+  context "setting associations with details" do
     before do
       spawn_model "Foo::User"
     end
 
-    it "handles a single 'has_many' relationship" do
-      Foo::User.has_many :comments, :class_name => "Post", :inverse_of => :admin
-      Foo::User.relationships[:has_many].should == [{ :name => :comments, :class_name => "Post", :path => "/comments", :inverse_of => :admin }]
+    it "handles a single 'has_many' association" do
+      Foo::User.has_many :comments, :class_name => "Post", :inverse_of => :admin, :data_key => :user_comments
+      Foo::User.associations[:has_many].should == [{ :name => :comments, :data_key => :user_comments, :class_name => "Post", :path => "/comments", :inverse_of => :admin }]
     end
 
-    it "handles a single 'has_one' relationship" do
-      Foo::User.has_one :category, :class_name => "Topic", :foreign_key => "topic_id"
-      Foo::User.relationships[:has_one].should == [{ :name => :category, :class_name => "Topic", :foreign_key => "topic_id", :path => "/category" }]
+    it "handles a single 'has_one' association" do
+      Foo::User.has_one :category, :class_name => "Topic", :foreign_key => "topic_id", :data_key => :topic
+      Foo::User.associations[:has_one].should == [{ :name => :category, :data_key => :topic, :class_name => "Topic", :foreign_key => "topic_id", :path => "/category" }]
     end
 
-    it "handles a single belongs_to relationship" do
-      Foo::User.belongs_to :organization, :class_name => "Business", :foreign_key => "org_id"
-      Foo::User.relationships[:belongs_to].should == [{ :name => :organization, :class_name => "Business", :foreign_key => "org_id", :path => "/organizations/:id" }]
+    it "handles a single belongs_to association" do
+      Foo::User.belongs_to :organization, :class_name => "Business", :foreign_key => "org_id", :data_key => :org
+      Foo::User.associations[:belongs_to].should == [{ :name => :organization, :data_key => :org, :class_name => "Business", :foreign_key => "org_id", :path => "/organizations/:id" }]
     end
 
-    context "inheriting relationships from a superclass" do
-      it "copies relationships to the subclass" do
+    context "inheriting associations from a superclass" do
+      it "copies associations to the subclass" do
         Foo::User.has_many :comments, :class_name => "Post"
         subclass = Class.new(Foo::User)
-        subclass.relationships.object_id.should_not == Foo::User.relationships.object_id
-        subclass.relationships[:has_many].length.should == 1
-        subclass.relationships[:has_many].first[:class_name].should == "Post"
+        subclass.associations.object_id.should_not == Foo::User.associations.object_id
+        subclass.associations[:has_many].length.should == 1
+        subclass.associations[:has_many].first[:class_name].should == "Post"
       end
     end
   end
 
-  context "handling relationships without details" do
+  context "handling associations without details" 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, {}, { :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/1") { |env| [200, {}, { :id => 1, :name => "Tobias Fünke", :comments => [{ :comment => { :id => 2, :body => "Tobias, you blow hard!", :user_id => 1 } }, { :comment => { :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, {}, { :id => 2, :name => "Lindsay Fünke", :organization_id => 2 }.to_json] }
-          stub.get("/users/1/comments") { |env| [200, {}, [{ :id => 4, :body => "They're having a FIRESALE?" }].to_json] }
-          stub.get("/users/2/comments") { |env| [200, {}, [{ :id => 4, :body => "They're having a FIRESALE?" }, { :id => 5, :body => "Is this the tiny town from Footloose?" }].to_json] }
+          stub.get("/users/1/comments") { |env| [200, {}, [{ :comment => { :id => 4, :body => "They're having a FIRESALE?" } }].to_json] }
+          stub.get("/users/2/comments") { |env| [200, {}, [{ :comment => { :id => 4, :body => "They're having a FIRESALE?" } }, { :comment => { :id => 5, :body => "Is this the tiny town from Footloose?" } }].to_json] }
           stub.get("/users/2/role") { |env| [200, {}, { :id => 2, :body => "User" }.to_json] }
           stub.get("/users/1/role") { |env| [200, {}, { :id => 3, :body => "User" }.to_json] }
           stub.get("/users/1/posts") { |env| [200, {}, {:id => 1, :body => 'blogging stuff', :admin_id => 1 }.to_json] }
-          stub.get("/organizations/1") { |env| [200, {}, { :id => 1, :name => "Bluth Company Foo" }.to_json] }
-          stub.post("/users") { |env| [200, {}, { :id => 5, :name => "Mr. Krabs", :comments => [{ :id => 99, :body => "Rodríguez, nasibisibusi?", :user_id => 5 }], :role => { :id => 1, :body => "Admin" }, :organization => { :id => 3, :name => "Krusty Krab" }, :organization_id => 3 }.to_json] }
-          stub.put("/users/5") { |env| [200, {}, { :id => 5, :name => "Clancy Brown", :comments => [{ :id => 99, :body => "Rodríguez, nasibisibusi?", :user_id => 5 }], :role => { :id => 1, :body => "Admin" }, :organization => { :id => 3, :name => "Krusty Krab" }, :organization_id => 3 }.to_json] }
-          stub.delete("/users/5") { |env| [200, {}, { :id => 5, :name => "Clancy Brown", :comments => [{ :id => 99, :body => "Rodríguez, nasibisibusi?", :user_id => 5 }], :role => { :id => 1, :body => "Admin" }, :organization => { :id => 3, :name => "Krusty Krab" }, :organization_id => 3 }.to_json] }
+          stub.get("/organizations/1") { |env| [200, {}, { :organization =>  { :id => 1, :name => "Bluth Company Foo" } }.to_json] }
+          stub.post("/users") { |env| [200, {}, { :id => 5, :name => "Mr. Krabs", :comments => [{ :comment => { :id => 99, :body => "Rodríguez, nasibisibusi?", :user_id => 5 } }], :role => { :id => 1, :body => "Admin" }, :organization => { :id => 3, :name => "Krusty Krab" }, :organization_id => 3 }.to_json] }
+          stub.put("/users/5") { |env| [200, {}, { :id => 5, :name => "Clancy Brown", :comments => [{ :comment => { :id => 99, :body => "Rodríguez, nasibisibusi?", :user_id => 5 } }], :role => { :id => 1, :body => "Admin" }, :organization => { :id => 3, :name => "Krusty Krab" }, :organization_id => 3 }.to_json] }
+          stub.delete("/users/5") { |env| [200, {}, { :id => 5, :name => "Clancy Brown", :comments => [{ :comment => { :id => 99, :body => "Rodríguez, nasibisibusi?", :user_id => 5 } }], :role => { :id => 1, :body => "Admin" }, :organization => { :id => 3, :name => "Krusty Krab" }, :organization_id => 3 }.to_json] }
 
           stub.get("/organizations/2") do |env|
             if env[:params]["admin"] == "true"
-              [200, {}, { :id => 2, :name => "Bluth Company (admin)" }.to_json]
+              [200, {}, { :organization => { :id => 2, :name => "Bluth Company (admin)" } }.to_json]
             else
-              [200, {}, { :id => 2, :name => "Bluth Company" }.to_json]
+              [200, {}, { :organization => { :id => 2, :name => "Bluth Company" } }.to_json]
             end
           end
         end
@@ -108,12 +108,16 @@ describe Her::Model::Relationships do
       end
       spawn_model "Foo::Comment" do
         belongs_to :user
+        parse_root_in_json true
       end
       spawn_model "Foo::Post" do
         belongs_to :admin, :class_name => 'Foo::User'
       end
 
-      spawn_model "Foo::Organization"
+      spawn_model "Foo::Organization" do
+        parse_root_in_json true
+      end
+
       spawn_model "Foo::Role"
 
       @user_with_included_data = Foo::User.find(1)
@@ -182,14 +186,14 @@ describe Her::Model::Relationships do
       @user_with_included_data.organization(:foo_id => 1).name.should == "Bluth Company Foo"
     end
 
-    it "can tell if it has a relationship" do
-      @user_without_included_data.has_relationship?(:unknown_relationship).should be_false
-      @user_without_included_data.has_relationship?(:organization).should be_true
+    it "can tell if it has a association" do
+      @user_without_included_data.has_association?(:unknown_association).should be_false
+      @user_without_included_data.has_association?(:organization).should be_true
     end
 
-    it "fetches the resource corresponding to a named relationship" do
-      @user_without_included_data.get_relationship(:unknown_relationship).should be_nil
-      @user_without_included_data.get_relationship(:organization).name.should == "Bluth Company"
+    it "fetches the resource corresponding to a named association" do
+      @user_without_included_data.get_association(:unknown_association).should be_nil
+      @user_without_included_data.get_association(:organization).name.should == "Bluth Company"
     end
 
     it "pass query string parameters when additional arguments are passed" do
@@ -216,21 +220,21 @@ describe Her::Model::Relationships do
     end
   end
 
-  context "handling relationships with details" do
+  context "handling associations with details" 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, {}, { :id => 1, :name => "Tobias Fünke", :organization => { :id => 1, :name => "Bluth Company" }, :organization_id => 1 }.to_json] }
+          stub.get("/users/1") { |env| [200, {}, { :id => 1, :name => "Tobias Fünke", :organization => { :id => 1, :name => "Bluth Company Inc." }, :organization_id => 1 }.to_json] }
           stub.get("/users/2") { |env| [200, {}, { :id => 2, :name => "Lindsay Fünke", :organization_id => 1 }.to_json] }
-          stub.get("/users/3") { |env| [200, {}, { :id => 2, :name => "Lindsay Fünke", :organization => nil }.to_json] }
+          stub.get("/users/3") { |env| [200, {}, { :id => 2, :name => "Lindsay Fünke", :company => nil }.to_json] }
           stub.get("/companies/1") { |env| [200, {}, { :id => 1, :name => "Bluth Company" }.to_json] }
         end
       end
 
       spawn_model "Foo::User" do
-        belongs_to :company, :path => "/organizations/:id", :foreign_key => :organization_id
+        belongs_to :company, :path => "/organizations/:id", :foreign_key => :organization_id, :data_key => :organization
       end
 
       spawn_model "Foo::Company"
@@ -243,11 +247,11 @@ describe Her::Model::Relationships do
     it "maps an array of included data through belongs_to" do
       @user_with_included_data.company.should be_a(Foo::Company)
       @user_with_included_data.company.id.should == 1
-      @user_with_included_data.company.name.should == "Bluth Company"
+      @user_with_included_data.company.name.should == "Bluth Company Inc."
     end
 
     it "does not map included data if it’s nil" do
-      @user_with_included_nil_data.organization.should be_nil
+      @user_with_included_nil_data.company.should be_nil
     end
 
     it "fetches data that was not included through belongs_to" do

data/spec/model/nested_attributes_spec.rb

@@ -2,7 +2,7 @@
 require File.join(File.dirname(__FILE__), "../spec_helper.rb")
 
 describe Her::Model::NestedAttributes do
-  context "with a belongs_to relation" do
+  context "with a belongs_to association" do
     before do
       Her::API.setup :url => "https://api.example.com" do |builder|
         builder.use Her::Middleware::FirstLevelParseJSON
@@ -35,7 +35,7 @@ describe Her::Model::NestedAttributes do
     end
   end
 
-  context "with a has_one relation" do
+  context "with a has_one association" do
     before do
       Her::API.setup :url => "https://api.example.com" do |builder|
         builder.use Her::Middleware::FirstLevelParseJSON
@@ -68,7 +68,7 @@ describe Her::Model::NestedAttributes do
     end
   end
 
-  context "with a has_many relation" do
+  context "with a has_many association" do
     before do
       Her::API.setup :url => "https://api.example.com" do |builder|
         builder.use Her::Middleware::FirstLevelParseJSON

data/spec/model/orm_spec.rb

@@ -145,7 +145,7 @@ describe Her::Model::ORM do
         builder.use Faraday::Request::UrlEncoded
         builder.adapter :test do |stub|
           stub.get("/users/1") { |env| [200, {}, { :id => 1, :friends => ["Maeby", "GOB", "Anne"] }.to_json] }
-          stub.get("/users/2") { |env| [200, {}, { :id => 1, :organization => true }.to_json] }
+          stub.get("/users/2") { |env| [200, {}, { :id => 1 }.to_json] }
         end
       end
 
@@ -155,16 +155,11 @@ describe Her::Model::ORM do
 
         def friends=(val)
           val = val.gsub("\r", "").split("\n").map { |friend| friend.gsub(/^\s*\*\s*/, "") } if val and val.is_a?(String)
-          @data[:friends] = val
+          @attributes[:friends] = val
         end
 
         def friends
-          @data[:friends].map { |friend| "* #{friend}" }.join("\n")
-        end
-
-        # Why would anybody want to do this? I don’t know.
-        def organization=(organization)
-          @data[:organization] = { :foo => :bar }
+          @attributes[:friends].map { |friend| "* #{friend}" }.join("\n")
         end
       end
     end
@@ -173,21 +168,16 @@ describe Her::Model::ORM do
       @user = User.find(1)
       @user.friends.should == "* Maeby\n* GOB\n* Anne"
       @user.instance_eval do
-        @data[:friends] = ["Maeby", "GOB", "Anne"]
+        @attributes[:friends] = ["Maeby", "GOB", "Anne"]
       end
     end
 
-    it "handles custom setters with relationships" do
-      @user = User.find(2)
-      @user.organization.should == { :foo => :bar }
-    end
-
     it "handles custom getters" do
       @user = User.new
       @user.friends = "* George\n* Oscar\n* Lucille"
       @user.friends.should == "* George\n* Oscar\n* Lucille"
       @user.instance_eval do
-        @data[:friends] = ["George", "Oscar", "Lucille"]
+        @attributes[:friends] = ["George", "Oscar", "Lucille"]
       end
     end
   end

data/spec/model/paths_spec.rb

@@ -61,7 +61,7 @@ describe Her::Model::Paths do
 
         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)
+          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\"}`.")
         end
       end
     end
@@ -115,12 +115,12 @@ describe Her::Model::Paths do
 
         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)
+          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\"}`.")
         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)
+          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\"}`.")
         end
       end
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: her
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 0.5.2
 platform: ruby
 authors:
 - Rémi Prévost
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-03-10 00:00:00.000000000 Z
+date: 2013-03-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -142,19 +142,20 @@ files:
 - lib/her/middleware/first_level_parse_json.rb
 - lib/her/middleware/second_level_parse_json.rb
 - lib/her/model.rb
+- lib/her/model/associations.rb
 - lib/her/model/base.rb
 - lib/her/model/http.rb
 - lib/her/model/introspection.rb
 - lib/her/model/nested_attributes.rb
 - lib/her/model/orm.rb
 - lib/her/model/paths.rb
-- lib/her/model/relationships.rb
 - lib/her/version.rb
 - spec/api_spec.rb
 - spec/collection_spec.rb
 - spec/middleware/accept_json_spec.rb
 - spec/middleware/first_level_parse_json_spec.rb
 - spec/middleware/second_level_parse_json_spec.rb
+- spec/model/associations_spec.rb
 - spec/model/callbacks_spec.rb
 - spec/model/dirty_spec.rb
 - spec/model/http_spec.rb
@@ -162,7 +163,6 @@ files:
 - spec/model/nested_attributes_spec.rb
 - spec/model/orm_spec.rb
 - spec/model/paths_spec.rb
-- spec/model/relationships_spec.rb
 - spec/model/validations_spec.rb
 - spec/model_spec.rb
 - spec/spec_helper.rb
@@ -197,6 +197,7 @@ test_files:
 - spec/middleware/accept_json_spec.rb
 - spec/middleware/first_level_parse_json_spec.rb
 - spec/middleware/second_level_parse_json_spec.rb
+- spec/model/associations_spec.rb
 - spec/model/callbacks_spec.rb
 - spec/model/dirty_spec.rb
 - spec/model/http_spec.rb
@@ -204,7 +205,6 @@ test_files:
 - spec/model/nested_attributes_spec.rb
 - spec/model/orm_spec.rb
 - spec/model/paths_spec.rb
-- spec/model/relationships_spec.rb
 - spec/model/validations_spec.rb
 - spec/model_spec.rb
 - spec/spec_helper.rb