her 0.2.6 → 0.3

data/.gitignore

@@ -4,3 +4,4 @@ Gemfile.lock
 pkg/*
 .yardoc
 doc
+rake

data/README.md

@@ -64,14 +64,16 @@ You can look into the `examples` directory for sample applications using Her.
 
 ## Middleware
 
-Since Her relies on [Faraday](https://github.com/technoweenie/faraday) to send HTTP requests, you can add additional middleware to handle requests and responses. Using the block in the `setup` call, you have access to Faraday’s `connection` object and are able to customize the middleware stack used on each request and response.
+Since Her relies on [Faraday](https://github.com/technoweenie/faraday) to send HTTP requests, you can choose the middleware used to handle requests and responses. Using the block in the `setup` call, you have access to Faraday’s `connection` object and are able to customize the middleware stack used on each request and response.
 
 ### Authentication
 
-Her doesn’t support any kind of authentication. However, it’s very easy to implement one with a request middleware. Using the connection block, we add it to the default list of middleware.
+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:
 
 ```ruby
-class MyAuthentication < Faraday::Middleware
+class TokenAuthentication < Faraday::Middleware
   def initialize(app, options={})
     @options = options
   end
@@ -84,7 +86,7 @@ end
 
 Her::API.setup :url => "https://api.example.com" do |connection|
   # This token could be stored in the client session
-  connection.use MyAuthentication, :token => "bb2b2dd75413d32c1ac421d39e95b978d1819ff611f68fc2fdd5c8b9c7331192"
+  connection.use TokenAuthentication, :token => "bb2b2dd75413d32c1ac421d39e95b978d1819ff611f68fc2fdd5c8b9c7331192"
 
   connection.use Faraday::Request::UrlEncoded
   connection.use Her::Middleware::DefaultParseJSON
@@ -106,9 +108,19 @@ By default, Her handles JSON data. It expects the resource/collection data to be
 [{ "id" : 1, "name" : "Tobias Fünke" }]
 ```
 
-However, you can define your own parsing method, using a response middleware. The middleware is expected to set `env[:body]` to a hash with three keys: `data`, `errors` and `metadata`. The following code enables parsing JSON data and treating the result as first-level properties. Using the connection block, we then replace the default parser with our custom parser.
+However, you can define your own parsing method using a response middleware. The middleware should set `env[:body]` to a hash with three keys: `data`, `errors` and `metadata`. The following code uses a custom middleware to parse the JSON data:
 
 ```ruby
+# Expects responses like:
+#
+#     {
+#       "result": {
+#         "id": 1,
+#         "name": "Tobias Fünke"
+#       },
+#       "errors" => []
+#     }
+#
 class MyCustomParser < Faraday::Response::Middleware
   def on_complete(env)
     json = MultiJson.load(env[:body], :symbolize_keys => true)
@@ -125,7 +137,6 @@ Her::API.setup :url => "https://api.example.com" do |connection|
   connection.use MyCustomParser
   connection.use Faraday::Adapter::NetHttp
 end
-# User.find(1) will now expect "https://api.example.com/users/1" to return something like '{ "result" => { "id": 1, "name": "Tobias Fünke" }, "errors" => [] }'
 ```
 
 ### OAuth
@@ -219,11 +230,12 @@ end
 
 ## Relationships
 
-You can define `has_many`, `has_one` and `belongs_to` relationships in your models. The relationship data is handled in two different ways. If there’s relationship data when parsing a resource, it will be used to create new Ruby objects.
+You can define `has_many`, `has_one` and `belongs_to` relationships in your models. The relationship data is handled in two different ways.
 
-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 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).
 
-For example, with this setup:
+For example:
 
 ```ruby
 class User
@@ -249,34 +261,51 @@ 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:
 
 ```ruby
-@user = User.find(1) # { :data => { :id => 1, :name => "George Michael Bluth", :comments => [{ :id => 1, :text => "Foo" }, { :id => 2, :text => "Bar" }], :role => { :id => 1, :name => "Admin" }, :organization => { :id => 2, :name => "Bluth Company" } }}
-@user.comments # => [#<Comment id=1>, #<Comment id=2>] fetched directly from @user
-@user.role # => #<Role id=1> fetched directly from @user
-@user.organization # => #<Organization id=2> fetched directly from @user
-```
-
-If there’s no relationship data in the resource, an extra HTTP request (to `GET /users/1/comments`) is made when calling the `#comments` method:
-
-```ruby
-@user = User.find(1) # { :data => { :id => 1, :name => "George Michael Bluth" }}
-@user.comments # => [#<Comment id=1>, #<Comment id=2>] fetched from /users/1/comments
+@user = User.find(1) 
+# { 
+#   :data => {
+#     :id => 1,
+#     :name => "George Michael Bluth",
+#     :comments => [
+#       { :id => 1, :text => "Foo" },
+#       { :id => 2, :text => "Bar" }
+#     ],
+#     :role => { :id => 1, :name => "Admin" },
+#     :organization => { :id => 2, :name => "Bluth Company" }
+#   }
+# }
+@user.comments
+# [#<Comment id=1 text="Foo">, #<Comment id=2 text="Bar">]
+@user.role
+# #<Role id=1 name="Admin">
+@user.organization
+# #<Organization id=2 name="Bluth Company">
 ```
 
-For `has_one` relationships, an extra HTTP request (to `GET /users/1/role`) is made when calling the `#role` method:
+If there’s no relationship 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" }}
-@user.role # => #<Role id=1> fetched from /users/1/role
-```
-
-For `belongs_to` relationships, an extra HTTP request (to `GET /organizations/2`) is made when calling the `#organization` method:
-
-```ruby
-@user = User.find(1) # { :data => { :id => 1, :name => "George Michael Bluth", :organization_id => 2 }}
-@user.organization # => #<Organization id=2> fetched from /organizations/2
+@user = User.find(1)
+# { :data => { :id => 1, :name => "George Michael Bluth", :organization_id => 2 }}
+
+# has_many relationship:
+@user.comments
+# GET /users/1/comments
+# [#<Comment id=1>, #<Comment id=2>]
+
+# has_one relationship:
+@user.role
+# GET /users/1/role
+# #<Role id=1>
+
+# belongs_to relationship:
+@user.organization
+# (the organization id comes from :organization_id, by default)
+# GET /organizations/2
+# #<Organization id=2>
 ```
 
-However, subsequent calls to `#comments`, `#role` and `#organization` will not trigger extra HTTP requests as the data has already been fetched.
+Subsequent calls to `#comments`, `#role` and `#organization` will not trigger extra HTTP requests and will return the cached objects.
 
 ## Hooks
 
@@ -307,14 +336,17 @@ class User
   custom_post :from_default
 end
 
-User.popular # => [#<User id=1>, #<User id=2>]
+User.popular
 # GET /users/popular
+# [#<User id=1>, #<User id=2>]
 
-User.unpopular # => [#<User id=3>, #<User id=4>]
+User.unpopular
 # GET /users/unpopular
+# [#<User id=3>, #<User id=4>]
 
-User.from_default(:name => "Maeby Fünke") # => #<User id=5>
+User.from_default(:name => "Maeby Fünke")
 # POST /users/from_default?name=Maeby+Fünke
+# #<User id=5 name="Maeby Fünke">
 ```
 
 You can also use `get`, `post`, `put` or `delete` (which maps the returned data to either a collection or a resource).
@@ -324,11 +356,13 @@ class User
   include Her::Model
 end
 
-User.get(:popular) # => [#<User id=1>, #<User id=2>]
+User.get(:popular)
 # GET /users/popular
+# [#<User id=1>, #<User id=2>]
 
-User.get(:single_best) # => #<User id=1>
+User.get(:single_best)
 # GET /users/single_best
+# #<User id=1>
 ```
 
 Also, `get_collection` (which maps the returned data to a collection of resources), `get_resource` (which maps the returned data to a single resource) or `get_raw` (which yields the parsed data return from the HTTP request) can also be used. Other HTTP methods are supported (`post_raw`, `put_resource`, etc.).
@@ -348,8 +382,12 @@ class User
   end
 end
 
-User.popular # => [#<User id=1>, #<User id=2>]
-User.total # => 42
+User.popular
+# GET /users/popular
+# [#<User id=1>, #<User id=2>]
+User.total
+# GET /users/stats
+# => 42
 ```
 
 You can also use full request paths (with strings instead of symbols).
@@ -359,8 +397,9 @@ class User
   include Her::Model
 end
 
-User.get("/users/popular") # => [#<User id=1>, #<User id=2>]
+User.get("/users/popular")
 # GET /users/popular
+# [#<User id=1>, #<User id=2>]
 ```
 
 ## Custom paths

data/lib/her/model/introspection.rb

@@ -1,6 +1,33 @@
 module Her
   module Model
     module Introspection
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        # Finds a class at the same level as this one or at the global level.
+        def nearby_class(name)
+          sibling_class(name) || name.constantize rescue nil
+        end
+
+        protected
+        # Looks for a class at the same level as this one with the given name.
+        # @private
+        def sibling_class(name)
+          if mod = self.containing_module
+            "#{mod.name}::#{name}".constantize rescue nil
+          else
+            name.constantize rescue nil
+          end
+        end
+
+        # If available, returns the containing Module for this class.
+        # @private
+        def containing_module # {{{
+          return unless self.name =~ /::/
+          self.name.split("::")[0..-2].join("::").constantize
+        end # }}}
+      end
+
       # Inspect an element, returns it for introspection.
       #
       # @example

data/lib/her/model/orm.rb

@@ -20,10 +20,8 @@ module Her
 
       # Initialize a collection of resources
       # @private
-      def self.initialize_collection(name, parsed_data={}) # {{{
-        collection_data = parsed_data[:data].map do |item_data|
-          Object.const_get(name.to_s.classify).new(item_data)
-        end
+      def self.initialize_collection(klass, parsed_data={}) # {{{
+        collection_data = parsed_data[:data].map { |item_data| klass.new(item_data) }
         Her::Collection.new(collection_data, parsed_data[:metadata], parsed_data[:errors])
       end # }}}
 
@@ -54,7 +52,7 @@ module Her
       #
       # @param [Array] parsed_data
       def new_collection(parsed_data) # {{{
-        Her::Model::ORM.initialize_collection(self.to_s.underscore, parsed_data)
+        Her::Model::ORM.initialize_collection(self, parsed_data)
       end # }}}
 
       # Return `true` if a resource was not saved yet

data/lib/her/model/paths.rb

@@ -35,8 +35,12 @@ module Her
       #   end
       #
       #   User.all # Fetched via GET /utilisateurs
-      def build_request_path(parameters={}) # {{{
-        (path = parameters.include?(:id) ? @her_resource_path : @her_collection_path).gsub(/:([\w_]+)/) do
+      def build_request_path(path=nil, parameters={}) # {{{
+        unless path.is_a?(String)
+          parameters = path || {}
+          path = parameters.include?(:id) ? @her_resource_path : @her_collection_path
+        end
+        path.gsub(/:([\w_]+)/) do
           # Look for :key or :_key, otherwise raise an exception
           parameters[$1.to_sym] || parameters["_#{$1}".to_sym] || raise(Her::Errors::PathError.new("Missing :_#{$1} parameter to build the request path (#{path})."))
         end

data/lib/her/model/relationships.rb

@@ -15,13 +15,13 @@ module Her
         @her_relationships.each_pair do |type, relationships|
           relationships.each do |relationship|
             name = relationship[:name]
-            class_name = relationship[:class_name]
+            klass = self.nearby_class(relationship[:class_name])
             next if !data.include?(name) or data[name].nil?
             data[name] = case type
               when :has_many
-                Her::Model::ORM.initialize_collection(class_name, :data => data[name])
+                Her::Model::ORM.initialize_collection(klass, :data => data[name])
               when :has_one, :belongs_to
-                Object.const_get(class_name).new(data[name])
+                klass.new(data[name])
               else
                 nil
             end
@@ -49,8 +49,18 @@ module Her
       #   @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 }.merge(attrs)
-        define_relationship(:has_many, attrs)
+        @her_relationships ||= {}
+        attrs = {
+          :class_name => name.to_s.classify,
+          :name => name,
+          :path => "/#{name}"
+        }.merge(attrs)
+        (@her_relationships[:has_many] ||= []) << attrs
+
+        define_method(name) do
+          klass = self.class.nearby_class(attrs[:class_name])
+          @data[name] ||= klass.get_collection("#{self.class.build_request_path(:id => id)}#{attrs[:path]}")
+        end
       end # }}}
 
       # Define an *has_one* relationship.
@@ -72,8 +82,18 @@ module Her
       #   @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 }.merge(attrs)
-        define_relationship(:has_one, attrs)
+        @her_relationships ||= {}
+        attrs = {
+          :class_name => name.to_s.classify,
+          :name => name,
+          :path => "/#{name}"
+        }.merge(attrs)
+        (@her_relationships[:has_one] ||= []) << attrs
+
+        define_method(name) do
+          klass = self.class.nearby_class(attrs[:class_name])
+          @data[name] ||= klass.get_resource("#{self.class.build_request_path(:id => id)}#{attrs[:path]}")
+        end
       end # }}}
 
       # Define a *belongs_to* relationship.
@@ -84,10 +104,10 @@ module Her
       # @example
       #   class User
       #     include Her::API
-      #     belongs_to :team
+      #     belongs_to :team, :class_name => "Group"
       #   end
       #
-      #   class Team
+      #   class Group
       #     include Her::API
       #   end
       #
@@ -95,36 +115,28 @@ module Her
       #   @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" }.merge(attrs)
-        define_relationship(:belongs_to, attrs)
-      end # }}}
-
-      private
-      # @private
-      def define_relationship(type, attrs) # {{{
         @her_relationships ||= {}
-        (@her_relationships[type] ||= []) << attrs
-        relationship_accessor(type, attrs)
-      end # }}}
+        attrs = {
+          :class_name => name.to_s.classify,
+          :name => name,
+          :foreign_key => "#{name}_id",
+          :path => "/#{name.to_s.pluralize}/:id"
+        }.merge(attrs)
+        (@her_relationships[:belongs_to] ||= []) << attrs
+
+        define_method(name) do
+          klass = self.class.nearby_class(attrs[:class_name])
+          @data[name] ||= klass.get_resource("#{klass.build_request_path(:id => @data[attrs[:foreign_key].to_sym])}")
+        end
+      end
 
       # @private
       def relationship_accessor(type, attrs) # {{{
         name = attrs[:name]
         class_name = attrs[:class_name]
         define_method(name) do
-          return @data[name] if @data.include?(name)
-
-          klass = Object.const_get(class_name)
-          path = self.class.build_request_path(:id => id)
-          @data[name] = case type
-            when :belongs_to
-              foreign_key = attrs[:foreign_key].to_sym
-              klass.get_resource("#{klass.build_request_path(:id => @data[foreign_key])}")
-            when :has_many
-              klass.get_collection("#{path}/#{name.to_s.pluralize}")
-            when :has_one
-              klass.get_resource("#{path}/#{name.to_s.singularize}")
-          end
+          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

data/lib/her/version.rb

@@ -1,3 +1,3 @@
 module Her
-  VERSION = "0.2.6"
+  VERSION = "0.3"
 end

data/spec/model/hooks_spec.rb

@@ -4,154 +4,154 @@ require File.join(File.dirname(__FILE__), "../spec_helper.rb")
 describe Her::Model::Hooks do
   context "adding hooks to a model" do
     before do # {{{
-      spawn_model :User
+      spawn_model "Foo::User"
     end # }}}
 
     describe "method hooks" do
       it "handles “before save” method hooks" do # {{{
-        User.before_save :set_internal_id
-        User.send(:hooks)[:before_save].length.should == 1
-        User.send(:hooks)[:before_save].first.class.should == Symbol
+        Foo::User.before_save :set_internal_id
+        Foo::User.send(:hooks)[:before_save].length.should == 1
+        Foo::User.send(:hooks)[:before_save].first.class.should == Symbol
       end # }}}
 
       it "handles “before create” method hooks" do # {{{
-        User.before_create :set_internal_id
-        User.send(:hooks)[:before_create].length.should == 1
-        User.send(:hooks)[:before_create].first.class.should == Symbol
+        Foo::User.before_create :set_internal_id
+        Foo::User.send(:hooks)[:before_create].length.should == 1
+        Foo::User.send(:hooks)[:before_create].first.class.should == Symbol
       end # }}}
 
       it "handles “before update” method hooks" do # {{{
-        User.before_update :set_internal_id
-        User.send(:hooks)[:before_update].length.should == 1
-        User.send(:hooks)[:before_update].first.class.should == Symbol
+        Foo::User.before_update :set_internal_id
+        Foo::User.send(:hooks)[:before_update].length.should == 1
+        Foo::User.send(:hooks)[:before_update].first.class.should == Symbol
       end # }}}
 
       it "handles “before destroy” method hooks" do # {{{
-        User.before_destroy :set_internal_id
-        User.send(:hooks)[:before_destroy].length.should == 1
-        User.send(:hooks)[:before_destroy].first.class.should == Symbol
+        Foo::User.before_destroy :set_internal_id
+        Foo::User.send(:hooks)[:before_destroy].length.should == 1
+        Foo::User.send(:hooks)[:before_destroy].first.class.should == Symbol
       end # }}}
 
       it "handles “after save” method hooks" do # {{{
-        User.after_save :set_internal_id
-        User.send(:hooks)[:after_save].length.should == 1
-        User.send(:hooks)[:after_save].first.class.should == Symbol
+        Foo::User.after_save :set_internal_id
+        Foo::User.send(:hooks)[:after_save].length.should == 1
+        Foo::User.send(:hooks)[:after_save].first.class.should == Symbol
       end # }}}
 
       it "handles “after create” method hooks" do # {{{
-        User.after_create :set_internal_id
-        User.send(:hooks)[:after_create].length.should == 1
-        User.send(:hooks)[:after_create].first.class.should == Symbol
+        Foo::User.after_create :set_internal_id
+        Foo::User.send(:hooks)[:after_create].length.should == 1
+        Foo::User.send(:hooks)[:after_create].first.class.should == Symbol
       end # }}}
 
       it "handles “after update” method hooks" do # {{{
-        User.after_update :set_internal_id
-        User.send(:hooks)[:after_update].length.should == 1
-        User.send(:hooks)[:after_update].first.class.should == Symbol
+        Foo::User.after_update :set_internal_id
+        Foo::User.send(:hooks)[:after_update].length.should == 1
+        Foo::User.send(:hooks)[:after_update].first.class.should == Symbol
       end # }}}
 
       it "handles “after destroy” method hooks" do # {{{
-        User.after_destroy :set_internal_id
-        User.send(:hooks)[:after_destroy].length.should == 1
-        User.send(:hooks)[:after_destroy].first.class.should == Symbol
+        Foo::User.after_destroy :set_internal_id
+        Foo::User.send(:hooks)[:after_destroy].length.should == 1
+        Foo::User.send(:hooks)[:after_destroy].first.class.should == Symbol
       end # }}}
     end
 
     describe "block hooks" do
       it "handles “before save” block hooks" do # {{{
-        User.before_save { |record| record.internal_id = 42 }
-        User.send(:hooks)[:before_save].length.should == 1
-        User.send(:hooks)[:before_save].first.class.should == Proc
+        Foo::User.before_save { |record| record.internal_id = 42 }
+        Foo::User.send(:hooks)[:before_save].length.should == 1
+        Foo::User.send(:hooks)[:before_save].first.class.should == Proc
       end # }}}
 
       it "handles “before create” block hooks" do # {{{
-        User.before_create { |record| record.internal_id = 42 }
-        User.send(:hooks)[:before_create].length.should == 1
-        User.send(:hooks)[:before_create].first.class.should == Proc
+        Foo::User.before_create { |record| record.internal_id = 42 }
+        Foo::User.send(:hooks)[:before_create].length.should == 1
+        Foo::User.send(:hooks)[:before_create].first.class.should == Proc
       end # }}}
 
       it "handles “before update” block hooks" do # {{{
-        User.before_update { |record| record.internal_id = 42 }
-        User.send(:hooks)[:before_update].length.should == 1
-        User.send(:hooks)[:before_update].first.class.should == Proc
+        Foo::User.before_update { |record| record.internal_id = 42 }
+        Foo::User.send(:hooks)[:before_update].length.should == 1
+        Foo::User.send(:hooks)[:before_update].first.class.should == Proc
       end # }}}
 
       it "handles “before destroy” block hooks" do # {{{
-        User.before_destroy { |record| record.internal_id = 42 }
-        User.send(:hooks)[:before_destroy].length.should == 1
-        User.send(:hooks)[:before_destroy].first.class.should == Proc
+        Foo::User.before_destroy { |record| record.internal_id = 42 }
+        Foo::User.send(:hooks)[:before_destroy].length.should == 1
+        Foo::User.send(:hooks)[:before_destroy].first.class.should == Proc
       end # }}}
 
       it "handles “after save” block hooks" do # {{{
-        User.after_save { |record| record.internal_id = 42 }
-        User.send(:hooks)[:after_save].length.should == 1
-        User.send(:hooks)[:after_save].first.class.should == Proc
+        Foo::User.after_save { |record| record.internal_id = 42 }
+        Foo::User.send(:hooks)[:after_save].length.should == 1
+        Foo::User.send(:hooks)[:after_save].first.class.should == Proc
       end # }}}
 
       it "handles “after create” block hooks" do # {{{
-        User.after_create { |record| record.internal_id = 42 }
-        User.send(:hooks)[:after_create].length.should == 1
-        User.send(:hooks)[:after_create].first.class.should == Proc
+        Foo::User.after_create { |record| record.internal_id = 42 }
+        Foo::User.send(:hooks)[:after_create].length.should == 1
+        Foo::User.send(:hooks)[:after_create].first.class.should == Proc
       end # }}}
 
       it "handles “after update” block hooks" do # {{{
-        User.after_update { |record| record.internal_id = 42 }
-        User.send(:hooks)[:after_update].length.should == 1
-        User.send(:hooks)[:after_update].first.class.should == Proc
+        Foo::User.after_update { |record| record.internal_id = 42 }
+        Foo::User.send(:hooks)[:after_update].length.should == 1
+        Foo::User.send(:hooks)[:after_update].first.class.should == Proc
       end # }}}
 
       it "handles “after destroy” block hooks" do # {{{
-        User.after_destroy { |record| record.internal_id = 42 }
-        User.send(:hooks)[:after_destroy].length.should == 1
-        User.send(:hooks)[:after_destroy].first.class.should == Proc
+        Foo::User.after_destroy { |record| record.internal_id = 42 }
+        Foo::User.send(:hooks)[:after_destroy].length.should == 1
+        Foo::User.send(:hooks)[:after_destroy].first.class.should == Proc
       end # }}}
     end
   end
 
   context "perform hooks on a 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.post("/users")     { |env| [200, {}, { :id => 1, :name => "Tobias Fünke" }.to_json] }
-            stub.get("/users/1")    { |env| [200, {}, { :id => 1, :name => "Tobias Fünke" }.to_json] }
-            stub.put("/users/1")    { |env| [200, {}, { :id => 1, :name => "Tobias Fünke" }.to_json] }
-            stub.delete("/users/1") { |env| [200, {}, { :id => 1, :name => "Tobias Fünke" }.to_json] }
-          end
-        end
-
-        spawn_model :User do
-          attr_accessor :internal_save_id, :internal_create_id, :internal_update_id, :internal_destroy_id
-          attr_accessor :internal_after_save_id, :internal_after_create_id, :internal_after_update_id, :internal_after_destroy_id
-
-          def change_internal_save_id; @internal_save_id = 100; end
-          def change_internal_create_id; @internal_create_id = 101; end
-          def change_internal_update_id; @internal_update_id = 102; end
-          def change_internal_destroy_id; @internal_destroy_id = 103; end
-
-          def change_internal_after_save_id; @internal_after_save_id = 100; end
-          def change_internal_after_create_id; @internal_after_create_id = 101; end
-          def change_internal_after_update_id; @internal_after_update_id = 102; end
-          def change_internal_after_destroy_id; @internal_after_destroy_id = 103; end
+    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.post("/users")     { |env| [200, {}, { :id => 1, :name => "Tobias Fünke" }.to_json] }
+          stub.get("/users/1")    { |env| [200, {}, { :id => 1, :name => "Tobias Fünke" }.to_json] }
+          stub.put("/users/1")    { |env| [200, {}, { :id => 1, :name => "Tobias Fünke" }.to_json] }
+          stub.delete("/users/1") { |env| [200, {}, { :id => 1, :name => "Tobias Fünke" }.to_json] }
         end
-      end # }}}
+      end
+
+      spawn_model "Foo::User" do
+        attr_accessor :internal_save_id, :internal_create_id, :internal_update_id, :internal_destroy_id
+        attr_accessor :internal_after_save_id, :internal_after_create_id, :internal_after_update_id, :internal_after_destroy_id
+
+        def change_internal_save_id; @internal_save_id = 100; end
+        def change_internal_create_id; @internal_create_id = 101; end
+        def change_internal_update_id; @internal_update_id = 102; end
+        def change_internal_destroy_id; @internal_destroy_id = 103; end
+
+        def change_internal_after_save_id; @internal_after_save_id = 100; end
+        def change_internal_after_create_id; @internal_after_create_id = 101; end
+        def change_internal_after_update_id; @internal_after_update_id = 102; end
+        def change_internal_after_destroy_id; @internal_after_destroy_id = 103; end
+      end
+    end # }}}
 
     describe "method hooks" do
       before do # {{{
-        User.before_save :change_internal_save_id
-        User.before_update :change_internal_update_id
-        User.before_create :change_internal_create_id
-        User.before_destroy :change_internal_destroy_id
-
-        User.after_save :change_internal_after_save_id
-        User.after_update :change_internal_after_update_id
-        User.after_create :change_internal_after_create_id
-        User.after_destroy :change_internal_after_destroy_id
+        Foo::User.before_save :change_internal_save_id
+        Foo::User.before_update :change_internal_update_id
+        Foo::User.before_create :change_internal_create_id
+        Foo::User.before_destroy :change_internal_destroy_id
+
+        Foo::User.after_save :change_internal_after_save_id
+        Foo::User.after_update :change_internal_after_update_id
+        Foo::User.after_create :change_internal_after_create_id
+        Foo::User.after_destroy :change_internal_after_destroy_id
       end # }}}
 
       it "perform “before save” “before create” method hook on Model#save without an ID" do # {{{
-        @user = User.new(:fullname => "Tobias Fünke")
+        @user = Foo::User.new(:fullname => "Tobias Fünke")
         @user.save
         @user.internal_save_id.should == 100
         @user.internal_create_id.should == 101
@@ -159,7 +159,7 @@ describe Her::Model::Hooks do
       end # }}}
 
       it "perform “before save” and “before update” method hook on Model#save with an ID" do # {{{
-        @user = User.find(1)
+        @user = Foo::User.find(1)
         @user.save
         @user.internal_save_id.should == 100
         @user.internal_create_id.should == nil
@@ -167,7 +167,7 @@ describe Her::Model::Hooks do
       end # }}}
 
       it "perform “before destroy” method hook on Model#destroy" do # {{{
-        @user = User.find(1)
+        @user = Foo::User.find(1)
         @user.destroy
         @user.internal_save_id.should == nil
         @user.internal_create_id.should == nil
@@ -176,7 +176,7 @@ describe Her::Model::Hooks do
       end # }}}
 
       it "perform “after save” “after create” method hook on Model#save without an ID" do # {{{
-        @user = User.new(:fullname => "Tobias Fünke")
+        @user = Foo::User.new(:fullname => "Tobias Fünke")
         @user.save
         @user.internal_after_save_id.should == 100
         @user.internal_after_create_id.should == 101
@@ -184,7 +184,7 @@ describe Her::Model::Hooks do
       end # }}}
 
       it "perform “after save” “after update” method hook on Model#save with an ID" do # {{{
-        @user = User.find(1)
+        @user = Foo::User.find(1)
         @user.save
         @user.internal_after_save_id.should == 100
         @user.internal_after_create_id.should == nil
@@ -192,14 +192,14 @@ describe Her::Model::Hooks do
       end # }}}
 
       it "perform “after save” “after update” method hook on Model.save_existing" do # {{{
-        @user = User.save_existing(1, { :fullname => "Tobias Fünke" })
+        @user = Foo::User.save_existing(1, { :fullname => "Tobias Fünke" })
         @user.internal_after_save_id.should == 100
         @user.internal_after_create_id.should == nil
         @user.internal_after_update_id.should == 102
       end # }}}
 
       it "perform “after save” “after create” method hook on Model.create" do # {{{
-        @user = User.create({ :fullname => "Tobias Fünke" })
+        @user = Foo::User.create({ :fullname => "Tobias Fünke" })
         @user.internal_after_save_id.should == 100
         @user.internal_after_create_id.should == 101
         @user.internal_after_update_id.should == nil
@@ -208,19 +208,19 @@ describe Her::Model::Hooks do
 
     describe "block hooks" do
       before do # {{{
-        User.before_save { |record| record.internal_save_id = 200 }
-        User.before_create { |record| record.internal_create_id = 201 }
-        User.before_update { |record| record.internal_update_id = 202 }
-        User.before_destroy { |record| record.internal_destroy_id = 203 }
-
-        User.after_save { |record| record.internal_after_save_id = 200 }
-        User.after_create { |record| record.internal_after_create_id = 201 }
-        User.after_update { |record| record.internal_after_update_id = 202 }
-        User.after_destroy { |record| record.internal_after_destroy_id = 203 }
+        Foo::User.before_save { |record| record.internal_save_id = 200 }
+        Foo::User.before_create { |record| record.internal_create_id = 201 }
+        Foo::User.before_update { |record| record.internal_update_id = 202 }
+        Foo::User.before_destroy { |record| record.internal_destroy_id = 203 }
+
+        Foo::User.after_save { |record| record.internal_after_save_id = 200 }
+        Foo::User.after_create { |record| record.internal_after_create_id = 201 }
+        Foo::User.after_update { |record| record.internal_after_update_id = 202 }
+        Foo::User.after_destroy { |record| record.internal_after_destroy_id = 203 }
       end # }}}
 
       it "perform “before save” and “before create” block hook on Model#save without an ID" do # {{{
-        @user = User.new(:fullname => "Tobias Fünke")
+        @user = Foo::User.new(:fullname => "Tobias Fünke")
         @user.save
         @user.internal_save_id.should == 200
         @user.internal_create_id.should == 201
@@ -228,7 +228,7 @@ describe Her::Model::Hooks do
       end # }}}
 
       it "perform “before save” and “before update” block hook on Model#save with an ID" do # {{{
-        @user = User.find(1)
+        @user = Foo::User.find(1)
         @user.save
         @user.internal_save_id.should == 200
         @user.internal_create_id.should == nil
@@ -236,7 +236,7 @@ describe Her::Model::Hooks do
       end # }}}
 
       it "perform “before destroy” block hook on Model#destroy" do # {{{
-        @user = User.find(1)
+        @user = Foo::User.find(1)
         @user.destroy
         @user.internal_save_id.should == nil
         @user.internal_create_id.should == nil
@@ -245,7 +245,7 @@ describe Her::Model::Hooks do
       end # }}}
 
       it "perform “after save” “after create” block hook on Model#save without an ID" do # {{{
-        @user = User.new(:fullname => "Tobias Fünke")
+        @user = Foo::User.new(:fullname => "Tobias Fünke")
         @user.save
         @user.internal_after_save_id.should == 200
         @user.internal_after_create_id.should == 201
@@ -253,7 +253,7 @@ describe Her::Model::Hooks do
       end # }}}
 
       it "perform “after save” “after update” block hook on Model#save with an ID" do # {{{
-        @user = User.find(1)
+        @user = Foo::User.find(1)
         @user.save
         @user.internal_after_save_id.should == 200
         @user.internal_after_create_id.should == nil