her 0.3.5 → 0.3.6

data/README.md

@@ -70,25 +70,40 @@ Since Her relies on [Faraday](https://github.com/technoweenie/faraday) to send H
 
 Her doesn’t support authentication by default. However, it’s easy to implement one with request middleware. Using the `connection` block, we can add it to the middleware stack.
 
-For example, to add a API token header to your requests, you would do something like this:
+For example, to add a API token header to your requests in a Rails application, you would do something like this:
 
 ```ruby
-class TokenAuthentication < Faraday::Middleware
+# app/controllers/application_controller.rb
+class ApplicationController < ActionController::Base
+  around_filter :do_with_authenticated_user
+
+  def as_authenticated_user
+    Thread.current[:my_api_token] = session[:my_api_token]
+    begin
+      yield
+    ensure
+      Thread.current[:my_access_token] = nil
+    end
+  end
+end
+
+# lib/my_token_authentication.rb
+class MyTokenAuthentication < Faraday::Middleware
   def initialize(app, options={})
     @app = app
-    @options = options
   end
 
   def call(env)
-    env[:request_headers]["X-API-Token"] = @options[:token] if @options.include?(:token)
+    env[:request_headers]["X-API-Token"] = Thread.current[:my_api_token] if Thread.current[:my_api_token].present?
     @app.call(env)
   end
 end
 
-Her::API.setup :url => "https://api.example.com" do |connection|
-  # This token could be stored in the client session
-  connection.use TokenAuthentication, :token => "bb2b2dd75413d32c1ac421d39e95b978d1819ff611f68fc2fdd5c8b9c7331192"
+# config/initializers/her.rb
+require "lib/my_token_authentication"
 
+Her::API.setup :url => "https://api.example.com" do |connection|
+  connection.use MyTokenAuthentication
   connection.use Faraday::Request::UrlEncoded
   connection.use Her::Middleware::DefaultParseJSON
   connection.use Faraday::Adapter::NetHttp
@@ -177,6 +192,8 @@ end
 @tweets = Tweet.get("/statuses/home_timeline.json")
 ```
 
+See the *Authentication* middleware section for an example of how to pass different credentials based on the current user.
+
 ### Caching
 
 Again, using the `faraday_middleware` makes it very easy to cache requests and responses:

data/lib/her/model.rb

@@ -24,12 +24,12 @@ module Her
     include Her::Model::ORM
     include Her::Model::Introspection
     include Her::Model::Paths
+    include Her::Model::Relationships
 
     # Class methods
     included do
       extend Her::Model::Base
       extend Her::Model::HTTP
-      extend Her::Model::Relationships
       extend Her::Model::Hooks
 
       # Define default settings
@@ -38,5 +38,21 @@ module Her
       resource_path "#{base_path}/:id"
       uses_api Her::API.default_api
     end
+
+    # Returns true if attribute_name is
+    # * in orm data
+    # * a relationship
+    def has_key?(attribute_name)
+      has_data?(attribute_name) ||
+      has_relationship?(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
+    def [](attribute_name)
+      get_data(attribute_name) ||
+      get_relationship(attribute_name)
+    end
   end
 end

data/lib/her/model/orm.rb

@@ -61,12 +61,12 @@ module Her
       end
 
       # Handles returning true for the accessible attributes
-      def has_key?(attribute_name)
+      def has_data?(attribute_name)
         @data.include?(attribute_name)
       end
 
       # Handles returning attribute value from data
-      def [](attribute_name)
+      def get_data(attribute_name)
         @data[attribute_name]
       end
 
@@ -134,7 +134,7 @@ module Her
 
         self.class.wrap_in_hooks(resource, *hooks) do |resource, klass|
           klass.request(params.merge(:_method => method, :_path => "#{request_path}")) do |parsed_data|
-            self.data = parsed_data[:data]
+            self.data = parsed_data[:data] if parsed_data[:data].any?
             self.metadata = parsed_data[:metadata]
             self.errors = parsed_data[:errors]
 
@@ -242,6 +242,7 @@ module Her
         def save_existing(id, params)
           resource = new(params.merge(:id => id))
           resource.save
+          resource
         end
 
         # Destroy an existing resource

data/lib/her/model/paths.rb

@@ -61,7 +61,7 @@ module Her
         def build_request_path(path=nil, parameters={})
           unless path.is_a?(String)
             parameters = path || {}
-            path = parameters.include?(:id) ? resource_path : collection_path
+            path = parameters.include?(:id) && !parameters[:id].nil? ? resource_path : collection_path
           end
 
           path.gsub(/:([\w_]+)/) do

data/lib/her/model/relationships.rb

@@ -2,161 +2,188 @@ module Her
   module Model
     # This module adds relationships to models
     module Relationships
-      # Return @her_relationships, lazily initialized with copy of the
-      # superclass' her_relationships, or an empty hash.
-      #
-      # @private
-      def relationships
-        @her_relationships ||= begin
-          if superclass.respond_to?(:relationships)
-            superclass.relationships.dup
-          else
-            {}
+      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)
+      end
+
+      # Returns the resource/collection corresponding to the relationship_name relationship.
+      def get_relationship(relationship_name)
+        send(relationship_name) if has_relationship?(relationship_name)
+      end
+
+      module ClassMethods
+        # Return @her_relationships, lazily initialized with copy of the
+        # superclass' her_relationships, or an empty hash.
+        #
+        # @private
+        def relationships
+          @her_relationships ||= begin
+            if superclass.respond_to?(:relationships)
+              superclass.relationships.dup
+            else
+              {}
+            end
           end
         end
-      end
 
-      # Parse relationships 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])
-            data[name] = case type
-              when :has_many
-                Her::Model::ORM.initialize_collection(klass, :data => data[name])
-              when :has_one, :belongs_to
-                klass.new(data[name])
-              else
-                nil
+        # Parse relationships 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])
+              data[name] = case type
+                when :has_many
+                  Her::Model::ORM.initialize_collection(klass, :data => data[name])
+                when :has_one, :belongs_to
+                  klass.new(data[name])
+                else
+                  nil
+              end
             end
           end
+          data
         end
-        data
-      end
 
-      # Define an *has_many* relationship.
-      #
-      # @param [Symbol] name The name of the model
-      # @param [Hash] attrs Options (currently not used)
-      #
-      # @example
-      #   class User
-      #     include Her::API
-      #     has_many :articles
-      #   end
-      #
-      #   class Article
-      #     include Her::API
-      #   end
-      #
-      #   @user = User.find(1)
-      #   @user.articles # => [#<Article(articles/2) id=2 title="Hello world.">]
-      #   # Fetched via GET "/users/1/articles"
-      def has_many(name, attrs={})
-        attrs = {
-          :class_name => name.to_s.classify,
-          :name => name,
-          :path => "/#{name}"
-        }.merge(attrs)
-        (relationships[:has_many] ||= []) << attrs
+        # Define an *has_many* relationship.
+        #
+        # @param [Symbol] name The name of the model
+        # @param [Hash] attrs Options (currently not used)
+        #
+        # @example
+        #   class User
+        #     include Her::API
+        #     has_many :articles
+        #   end
+        #
+        #   class Article
+        #     include Her::API
+        #   end
+        #
+        #   @user = User.find(1)
+        #   @user.articles # => [#<Article(articles/2) id=2 title="Hello world.">]
+        #   # Fetched via GET "/users/1/articles"
+        def has_many(name, attrs={})
+          attrs = {
+            :class_name     => name.to_s.classify,
+            :name           => name,
+            :path           => "/#{name}",
+            :inverse_of => nil
+          }.merge(attrs)
+          (relationships[: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]}")
+            else
+              @data[name] ||= klass.get_collection("#{self.class.build_request_path(:id => id)}#{attrs[:path]}")
+            end
+
+            inverse_of = if attrs[:inverse_of]
+                               attrs[:inverse_of]
+                            else
+                             self.class.name.split('::').last.tableize.singularize
+                           end
+            @data[name].each do |entry|
+              entry.send("#{inverse_of}=", self)
+            end
 
-        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_collection("#{self.class.build_request_path(method_attrs.merge(:id => id))}#{attrs[:path]}")
-          else
-            @data[name] ||= klass.get_collection("#{self.class.build_request_path(:id => id)}#{attrs[:path]}")
+            @data[name]
           end
         end
-      end
 
-      # Define an *has_one* relationship.
-      #
-      # @param [Symbol] name The name of the model
-      # @param [Hash] attrs Options (currently not used)
-      #
-      # @example
-      #   class User
-      #     include Her::API
-      #     has_one :organization
-      #   end
-      #
-      #   class Organization
-      #     include Her::API
-      #   end
-      #
-      #   @user = User.find(1)
-      #   @user.organization # => #<Organization(organizations/2) id=2 name="Foobar Inc.">
-      #   # Fetched via GET "/users/1/organization"
-      def has_one(name, attrs={})
-        attrs = {
-          :class_name => name.to_s.classify,
-          :name => name,
-          :path => "/#{name}"
-        }.merge(attrs)
-        (relationships[:has_one] ||= []) << attrs
+        # Define an *has_one* relationship.
+        #
+        # @param [Symbol] name The name of the model
+        # @param [Hash] attrs Options (currently not used)
+        #
+        # @example
+        #   class User
+        #     include Her::API
+        #     has_one :organization
+        #   end
+        #
+        #   class Organization
+        #     include Her::API
+        #   end
+        #
+        #   @user = User.find(1)
+        #   @user.organization # => #<Organization(organizations/2) id=2 name="Foobar Inc.">
+        #   # Fetched via GET "/users/1/organization"
+        def has_one(name, attrs={})
+          attrs = {
+            :class_name => name.to_s.classify,
+            :name => name,
+            :path => "/#{name}"
+          }.merge(attrs)
+          (relationships[: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]}")
-          else
-            @data[name] ||= klass.get_resource("#{self.class.build_request_path(:id => id)}#{attrs[:path]}")
+          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]}")
+            else
+              @data[name] ||= klass.get_resource("#{self.class.build_request_path(:id => id)}#{attrs[:path]}")
+            end
           end
         end
-      end
 
-      # Define a *belongs_to* relationship.
-      #
-      # @param [Symbol] name The name of the model
-      # @param [Hash] attrs Options (currently not used)
-      #
-      # @example
-      #   class User
-      #     include Her::API
-      #     belongs_to :team, :class_name => "Group"
-      #   end
-      #
-      #   class Group
-      #     include Her::API
-      #   end
-      #
-      #   @user = User.find(1)
-      #   @user.team # => #<Team(teams/2) id=2 name="Developers">
-      #   # Fetched via GET "/teams/2"
-      def belongs_to(name, attrs={})
-        attrs = {
-          :class_name => name.to_s.classify,
-          :name => name,
-          :foreign_key => "#{name}_id",
-          :path => "/#{name.to_s.pluralize}/:id"
-        }.merge(attrs)
-        (relationships[:belongs_to] ||= []) << attrs
+        # Define a *belongs_to* relationship.
+        #
+        # @param [Symbol] name The name of the model
+        # @param [Hash] attrs Options (currently not used)
+        #
+        # @example
+        #   class User
+        #     include Her::API
+        #     belongs_to :team, :class_name => "Group"
+        #   end
+        #
+        #   class Group
+        #     include Her::API
+        #   end
+        #
+        #   @user = User.find(1)
+        #   @user.team # => #<Team(teams/2) id=2 name="Developers">
+        #   # Fetched via GET "/teams/2"
+        def belongs_to(name, attrs={})
+          attrs = {
+            :class_name => name.to_s.classify,
+            :name => name,
+            :foreign_key => "#{name}_id",
+            :path => "/#{name.to_s.pluralize}/:id"
+          }.merge(attrs)
+          (relationships[: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]))}")
-          else
-            @data[name] ||= klass.get_resource("#{klass.build_request_path(:id => @data[attrs[:foreign_key].to_sym])}")
+          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]))}")
+            else
+              @data[name] ||= klass.get_resource("#{klass.build_request_path(:id => @data[attrs[:foreign_key].to_sym])}")
+            end
           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])}")
+        # @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])}")
+          end
         end
       end
     end

data/lib/her/version.rb

@@ -1,3 +1,3 @@
 module Her
-  VERSION = "0.3.5"
+  VERSION = "0.3.6"
 end

data/spec/model/orm_spec.rb

@@ -81,16 +81,16 @@ describe Her::Model::ORM do
       @new_user.should respond_to(:fullname?)
     end
 
-    it "handles has_key for getter" do
+    it "handles has_data? for getter" do
       @new_user = Foo::User.new(:fullname => 'Mayonegg')
-      @new_user.should_not have_key(:unknown_method_for_a_user)
-      @new_user.should have_key(:fullname)
+      @new_user.should_not have_data(:unknown_method_for_a_user)
+      @new_user.should have_data(:fullname)
     end
 
-    it "handles [] for getter" do
+    it "handles get_data for getter" do
       @new_user = Foo::User.new(:fullname => 'Mayonegg')
-      @new_user[:unknown_method_for_a_user].should be_nil
-      @new_user[:fullname].should == 'Mayonegg'
+      @new_user.get_data(:unknown_method_for_a_user).should be_nil
+      @new_user.get_data(:fullname).should == 'Mayonegg'
     end
   end
 
@@ -272,6 +272,12 @@ describe Her::Model::ORM do
       @company = Foo::Company.new
       @company.save.should be_false
     end
+
+    it "don't overwrite data if response is empty" do
+      @company = Foo::Company.new(:name => 'Company Inc.')
+      @company.save.should be_false
+      @company.name.should == "Company Inc."
+    end
   end
 
   context "updating resources" do

data/spec/model/paths_spec.rb

@@ -11,6 +11,7 @@ describe Her::Model::Paths do
       describe "#build_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"
         end
 

data/spec/model/relationships_spec.rb

@@ -9,13 +9,13 @@ describe Her::Model::Relationships do
 
     it "handles a single 'has_many' relationship" do
       Foo::User.has_many :comments
-      Foo::User.relationships[:has_many].should == [{ :name => :comments, :class_name => "Comment", :path => "/comments" }]
+      Foo::User.relationships[:has_many].should == [{ :name => :comments, :class_name => "Comment", :path => "/comments", :inverse_of => nil }]
     end
 
     it "handles multiples 'has_many' relationship" do
       Foo::User.has_many :comments
       Foo::User.has_many :posts
-      Foo::User.relationships[:has_many].should == [{ :name => :comments, :class_name => "Comment", :path => "/comments" }, { :name => :posts, :class_name => "Post", :path => "/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 }]
     end
 
     it "handles a single 'has_one' relationship" do
@@ -47,8 +47,8 @@ describe Her::Model::Relationships do
     end
 
     it "handles a single 'has_many' relationship" do
-      Foo::User.has_many :comments, :class_name => "Post"
-      Foo::User.relationships[:has_many].should == [{ :name => :comments, :class_name => "Post", :path => "/comments" }]
+      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 }]
     end
 
     it "handles a single 'has_one' relationship" do
@@ -78,12 +78,13 @@ describe Her::Model::Relationships do
         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!" }, { :id => 3, :body => "I wouldn't mind kissing that man between the cheeks, so to speak" }], :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 => [{ :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, {}, { :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/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.get("/organizations/2") { |env| [200, {}, { :id => 2, :name => "Bluth Company" }.to_json] }
         end
@@ -93,10 +94,16 @@ describe Her::Model::Relationships do
         has_many :comments
         has_one :role
         belongs_to :organization
+        has_many :posts, :inverse_of => :admin
+      end
+      spawn_model "Foo::Comment" do
+        belongs_to :user
+      end
+      spawn_model "Foo::Post" do
+        belongs_to :admin, :class_name => 'Foo::User'
       end
 
       spawn_model "Foo::Organization"
-      spawn_model "Foo::Comment"
       spawn_model "Foo::Role"
 
       @user_with_included_data = Foo::User.find(1)
@@ -110,6 +117,14 @@ describe Her::Model::Relationships do
       @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 "uses the given inverse_of key to set the parent model" do
+      @user_with_included_data.posts.first.admin.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
@@ -152,6 +167,16 @@ describe Her::Model::Relationships do
     it "fetches belongs_to data even if it was included, only if called with parameters" 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
+    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"
+    end
   end
 
   context "handling relationships with details" do

data/spec/model_spec.rb

@@ -0,0 +1,43 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe Her::Model 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" }.to_json] }
+        stub.get("/users/1/comments") { |env| [200, {}, [{ :id => 4, :body => "They're having a FIRESALE?" }].to_json] }
+      end
+    end
+
+    spawn_model "Foo::User" do
+      has_many :comments
+    end
+
+    spawn_model "Foo::Comment"
+
+    @user_without_included_data = Foo::User.find(1)
+  end
+
+  it "handles has_key? for data" do
+    @user_without_included_data.should_not have_key(:unknown_method_for_a_user)
+    @user_without_included_data.should have_key(:name)
+  end
+
+  it "handles has_key? for relationships" do
+    @user_without_included_data.should_not have_key(:unknown_method_for_a_user)
+    @user_without_included_data.should have_key(:comments)
+  end
+
+  it "handles [] for data" do
+    @user_without_included_data[:unknown_method_for_a_user].should be_nil
+    @user_without_included_data[:name].should == "Tobias Fünke"
+  end
+
+  it "handles [] for relationships" do
+    @user_without_included_data[:unknown_relationship].should be_nil
+    @user_without_included_data[:comments].first.body.should == "They're having a FIRESALE?"
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: her
 version: !ruby/object:Gem::Version
-  version: 0.3.5
+  version: 0.3.6
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-12-01 00:00:00.000000000 Z
+date: 2012-12-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -255,6 +255,7 @@ files:
 - spec/model/orm_spec.rb
 - spec/model/paths_spec.rb
 - spec/model/relationships_spec.rb
+- spec/model_spec.rb
 - spec/spec_helper.rb
 homepage: http://remiprev.github.com/her
 licenses:
@@ -271,7 +272,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -27727532175681908
+      hash: -1080420939636029022
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -280,7 +281,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -27727532175681908
+      hash: -1080420939636029022
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.23
@@ -299,5 +300,6 @@ test_files:
 - spec/model/orm_spec.rb
 - spec/model/paths_spec.rb
 - spec/model/relationships_spec.rb
+- spec/model_spec.rb
 - spec/spec_helper.rb
 has_rdoc: