roda-rest_api 1.4.5 → 2.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c384fef43088fdccb5d94c332d3d02d820ef1335
-  data.tar.gz: a5162d2d027be2e5aa6441e36bd854658958bdf0
+  metadata.gz: 3d5c2fcc7e1accb98d420dab826d45d09e562f10
+  data.tar.gz: 3c0d41e7da9e9e2f9079a07298f38600217d8789
 SHA512:
-  metadata.gz: 5c353bb7255e621679c71de400e7b7ef23752a33247d028b0ab9e35b0e373b5d078374a504bc0f9a43c932948c77275c9ae490ce8fedfa103a431bdb41a8ef80
-  data.tar.gz: 05bc814b93814c1d2c5ec01b2fac41094f28e07e3fbfb0ef075adb9238cb48181c03e5a9a7cc1ae4d7ff10f6480c41ae70070f63d6d05c87a32752d64fbe2b5c
+  metadata.gz: 9f070e65992e1a696917d4f42c04904982d17cb2a2e05491cc9c3dc212d596858d1bbb1c8179415f4480b873983bea9a1dfd986dea1c9e3bb563e9f8188d636c
+  data.tar.gz: bf5acc47f30a35d9eea74137e1c2a3b9e81d5a2fd210c0c9fd8bd6476052bb8a257be370faad8d3c7f7854fe3a6d0a31b3e1a6569a588fff6331cbc2250c48fe

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/Gemfile

@@ -0,0 +1,10 @@
+source 'https://rubygems.org'
+
+gem 'roda', '~> 2'
+	
+group :develpment do
+  gem 'rake', '~> 10'
+  gem 'minitest', '~> 5.5'
+  gem 'rack-test', '~> 0.6'
+  gem 'jeweler', '~> 2.0'
+end

data/README.md

@@ -0,0 +1,302 @@
+Roda plugin for RESTful APIs
+=============
+
+### Quick start
+
+Install gem with
+
+    gem 'roda-rest_api'          #Gemfile
+
+or
+
+    gem install roda-rest_api    #Manual
+
+Create rack app 
+
+```ruby
+#api.ru
+
+require 'roda/rest_api'
+require 'json'
+
+class App < Roda
+  
+  plugin :rest_api
+  
+  route do |r|
+    r.api do
+      r.version 3 do
+        r.resource :things do |things|
+          things.list {|param| ['foo', 'bar']}
+          things.routes :index
+        end
+      end
+    end
+  end
+end
+
+run App
+```
+    
+And run with
+
+    bundle exec rackup api.ru
+
+Try it out on:
+
+    curl http://127.0.0.1:9292/api/v3/things
+
+
+### Usage
+
+```ruby
+route do |r|
+  r.api path:'', subdomain:'api' do   # 'mount' on api.example.com/v1/...
+    r.version 1 do
+
+      #define all 7 routes:
+      # index   - GET /v1/songs
+      # show    - GET /v1/songs/:id
+      # create  - POST /v1/songs
+      # update  - PUT | PATCH /v1/songs/:id
+      # destroy - DELETE /v1/songs/:id
+      # edit    - GET /v1/songs/:id/edit
+      # new     - GET /v1/songs/new
+      
+      # call permit to whitelist allowed parameters for save callback
+      
+      r.resource :songs do |songs|
+        songs.list   { |params| Song.where(params).all }      #index
+        songs.one    { |params| Song[params[:id]]  }          #show, edit, new
+        songs.delete { |params| Song[params[:id]].destroy }   #destroy
+        songs.save   { |atts|  Song.create_or_update(atts) }  #create, update
+        songs.permit :title, author: [:name, :address]
+      end
+
+      #define 2 routes and custom serializer, custom primary key:
+      # index   - GET /v1/artists
+      # show    - GET /v1/artists/:id
+
+      r.resource :artists, content_type: 'application/xml', primary_key: :artist_id do |artists|
+        artists.list      { |params| Artist.where(params).all }
+        artists.one       { |params| Artist[params[:artist_id]]  }
+        artists.serialize { |result| ArtistSerializer.xml(result) }
+        artists.routes :index, :show
+      end
+      
+      #define 6 singleton routes:
+      # show    - GET /v1/profile
+      # create  - POST /v1/profile
+      # update  - PUT | PATCH /v1/profile
+      # destroy - DELETE /v1/profile
+      # edit    - GET /v1/profile/edit
+      # new     - GET /v1/profile/new
+      
+      r.resource :profile, singleton: true do |profile|
+        profile.one     { |params| current_user.profile  }                      #show, edit, new
+        profile.save    { |atts| current_user.profile.create_or_update(atts)  } #create, update
+        profile.delete  { |params| current_user.profile.destroy  }              #destroy
+        profile.permit :name, :address
+      end
+
+      #define nested routes
+      # index   - GET /v1/albums/:parent_id/songs
+      # show    - GET /v1/albums/:parent_id/songs/:id
+      # index   - GET /v1/albums/:album_id/artwork
+      # index   - GET /v1/albums/favorites
+      # show    - GET /v1/albums/favorites/:id
+      
+      r.resource :albums do |albums|
+        r.resource :songs do |songs|
+          songs.list { |params| Song.where({ :album_id => params[:parent_id] }) }
+          songs.one  { |params| Song[params[:id]] 	}
+          songs.routes :index, :show
+        end
+        r.resource :artwork, parent_key: :album_id do |artwork|
+          artwork.list { |params| Artwork.where({ :album_id => params[:album_id] }).all }
+          artwork.routes :index
+        end
+        r.resource :favorites, bare: true do |favorites|
+          favorites.list  { |params| Favorite.where(params).all  }
+          favorites.one   { |params| Favorite[params[:id]] )  }
+          favorites.routes :index, :show
+        end
+      end
+      
+      #call block before route is called
+      
+      r.resource :user, singleton: true do |user|
+        user.save {|atts| User.create_or_update(atts) }
+        user.routes :create    # public
+        user.routes :update do # private
+          authenticate!
+        end
+      end
+      
+      #define custom routes
+      
+      r.resource :albums do
+        r.index do          # GET /v1/albums
+          # list albums
+        end
+        r.create do         # POST /v1/albums
+          # create album
+        end
+        r.show do |id|      # GET /v1/albums/:id
+          # show album
+        end
+        r.update do |id|    # PATCH | PUT /v1/albums/:id
+          # update album
+        end
+        r.destroy do |id|   # DELETE /v1/albums/:id
+          # delete album
+        end
+        r.edit do |id|      # GET /v1/albums/:id/edit
+          # edit album
+        end
+        r.new do            # GET /v1/albums/new
+          # new album
+        end
+      end
+
+    end
+  end
+end
+```
+
+###Options
+
+The plugin supports several options serialize, content_type, wrapper and id_pattern to modify processing of the request. Besides these, any number of custom options can be passed, which can be handy for the wrapper option.
+Each option can be specified and overridden at the api, version or resource level.
+
+####Serialization and content type
+
+A serializer is an object that responds to :serialize and returns a string. Optionally it can provide the content_type, which may also be specified inline. Serialization can also be specified within a block inside the resource.
+
+```ruby
+class XMLSerializer
+
+  def serialize(result)   #required
+    result.to_xml
+  end
+
+  def content_type        #optional
+    'text/xml'
+  end
+
+end
+
+class CSVSerializer
+
+  def serialize(result)
+    result.to_csv
+  end
+
+end
+
+
+class App < Roda
+    
+  plugin :rest_api
+
+  route do |r|
+    r.api serializer: XMLSerializer.new
+      r.resource :things do |things|
+        things.list {|param| ['foo', 'bar']}
+        things.routes :index
+      end
+      r.resource :objects, serializer: CSVSerializer.new, content_type: 'text/csv' do |objects|
+        objects.one {|param| Object.find(param) }
+        objects.routes :show
+      end
+      r.resource :items do |items|
+        items.list {|param| Item.where(param) }
+        items.routes :index
+        items.serialize content_type: 'text/plain' do |result| #inline specification
+          result.to_s
+        end
+      end
+
+    end
+  end
+end
+```
+
+####Wrapper
+
+A wrapper module can be specified, containing one or more 'around_*' methods. These methods should yield with the passed arguments. Wrappers can be used for cleaning up incoming parameters, database transactions, authorization checking or serialization. A resource can hold a generic :resource option, that can be used for providing extra info to the wrapper. It can be useful to set a custom option like model_class on a resource when using wrappers.
+
+```ruby
+module Wrapper
+
+  def around_save(atts)
+    # actions before save
+    result = yield(atts)  # call save action
+    #actions after save
+    result
+  end
+  
+  # around_one, around_list, around_delete
+end
+
+module SpecialWrapper
+
+  def around_delete(atts)
+    model_class = opts[:model_class]
+    if current_user.can_delete(model_class[atts[:id]])
+      yield(atts)
+    else
+      #not allowed
+    end
+  end
+  
+  def current_user
+    @request.current_user
+  end
+
+end
+
+class App < Roda
+
+  plugin :rest_api
+
+  route do |r|
+    r.api wrapper: Wrapper
+      r.resource :things do |things|
+        things.one {|params| Thing.find(params) }          # will be called inside the 'Wrapper#around_one' method
+        things.list {|params| Thing.where(params) }        # will be called inside the 'Wrapper#around_list' method
+        things.save {|atts| Thing.create_or_update(atts) } # will be called inside the 'Wrapper#around_save' method
+        things.delete {|params| Thing.destroy(params) }    # will be called inside the 'Wrapper#around_delete' method
+      end
+      r.resource :items, wrapper: SpecialWrapper, resource: {model_class: Item} do |items|
+        items.delete {|params| Item.destroy(params) }    # will be called inside the 'SpecialWrapper#around_delete' method
+      end
+
+    end
+  end
+end
+```
+
+####ID pattern
+
+To support various id formats, one of the symbol_matcher symbols or a regex can be specified to match custom id formats.
+The plugin adds the :uuid symbol for 8-4-4-4-12 formatted UUIDs.
+
+```ruby
+  uuid_pat = /\w{8}-\w{4}-\w{4}-\w{4}-\w{12}/
+  r.api id_pattern: uuid_pat
+    r.resource :things do |things|
+      things.one {|params| Thing.find(params) }
+      r.resource :parts, id_pattern: /part(\d+)/ do |parts|
+        parts.one {|params| Part.find(params) }
+      end
+
+    end
+  end
+  
+  # responds to /things/7e554915-210b-4dxe-a88b-3a09a5e790ge/parts/part123
+```
+
+### Caveat
+
+This plugin catches StandardError when performing the data access methods (list, one, save, delete) and will return a 404 or 422 response code when an error is thrown. When ENV['RACK_ENV'] is set to 'development' the error will be raised, but in all other cases it will fail silently. Be aware that ENV['RACK_ENV'] may be blank, so you won't see any errors even in development. A better approach is to develop and test the data access methods in isolation.

data/Rakefile

@@ -0,0 +1,22 @@
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+	t.libs << "test"
+	t.pattern = "test/*_test.rb"
+end
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+	# gem is a Gem::Specification... see http://guides.rubygems.org/specification-reference/ for more options
+	gem.name = "roda-rest_api"
+	gem.homepage = "http://github.com/beno/roda-rest_api"
+	gem.license = "MIT"
+	gem.summary = %Q{Restful resources for Roda}
+	gem.description = %Q{Create restful API easily with the Roda framework}
+	gem.email = "michelbenevento@yahoo.com"
+	gem.authors = ["Michel Benevento"]
+	gem.version = "2.0.1"
+	# dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+

data/VERSION

@@ -0,0 +1 @@
+2.0.1

data/lib/roda/plugins/rest_api.rb

@@ -1,267 +1,319 @@
 class Roda
-	module RodaPlugins
+  module RodaPlugins
 
-		module RestApi
+    module RestApi
+      
+      class DefaultSerializer
+        def serialize(result)
+          result.is_a?(String) ? result : result.to_json
+        end
+      end
 
-			APPLICATION_JSON = 'application/json'.freeze
-			SINGLETON_ROUTES = %i{ show create update destroy edit new }.freeze
+      APPLICATION_JSON = 'application/json'.freeze
+      SINGLETON_ROUTES = %i{ create new update show destroy edit }.freeze
+      OPTS = {}.freeze
+      
+      def self.load_dependencies(app, _opts = OPTS)
+        app.plugin :all_verbs
+        app.plugin :symbol_matchers
+        app.plugin :header_matchers
+        app.plugin :drop_body
+      end
+      
+      def self.configure(app, opts = OPTS)
+        all_keys = Resource::OPTIONS.keys << :serialize
+        if (opts.keys & all_keys).any?
+          raise "For version 2.0 all options [#{Resource::OPTIONS.keys.join(' ')}] must be set at the api, version or resource level."
+        end
+      end
+            
+      class Resource
+        
+        attr_reader :request, :path, :singleton, :parent, :id_pattern
+        attr_accessor :captures
+        
+        OPTIONS = { singleton: false,
+          primary_key: "id",
+          parent_key: "parent_id",
+          id_pattern: /(\d+)/,
+          content_type: APPLICATION_JSON,
+          bare: false,
+          serializer: RestApi::DefaultSerializer.new,
+          wrapper: nil,
+          resource: nil }.freeze
+                
+        def initialize(path, request, parent, option_chain=[])
+          @request = request
+          @path = path.to_s
+          traverse_options option_chain
+          if parent
+            @parent = parent
+            @path = ":id/#{@path}" unless @bare
+          end
+        end
+        
+        [:list, :one, :save, :delete, :serialize].each do |meth|
+          define_method meth do |&block|
+            self.instance_variable_set("@#{meth}", block) if block
+            self.instance_variable_get("@#{meth}") || ->(_){raise NotImplementedError, meth.to_s}
+          end
+        end
+        
+        def content_type
+          if @serializer && @serializer.respond_to?(:content_type)
+            @serializer.content_type
+          else
+            @content_type
+          end
+        end
+        
+        def opts
+          @resource || {}
+        end
+                        
+        def routes(*routes)
+          routes! if @routes
+          yield if block_given?
+          @routes = routes
+        end
+        
+        def permit(*permitted)
+          @permitted = permitted
+        end
+          
+        def routes!
+          unless @routes
+            @routes = SINGLETON_ROUTES.dup
+            @routes << :index unless @singleton
+          end
+          @routes.each { |route| @request.send(route) }
+        end
+        
+        POST_BODY  = 'rack.input'.freeze
+        FORM_INPUT = 'rack.request.form_input'.freeze
+        FORM_HASH  = 'rack.request.form_hash'.freeze
 
-			def self.load_dependencies(app, _opts = {})
-				app.plugin :all_verbs
-				app.plugin :symbol_matchers
-				app.plugin :header_matchers
-				app.plugin :drop_body
-			end
-			
-			class Resource
-				
-				attr_reader :request, :path, :singleton, :content_type, :parent
-				attr_accessor :captures
-				
-				def initialize(path, request, parent, options={})
-					@request = request
-					@path = path.to_s
-					bare = options.delete(:bare) || false
-					@singleton = options.delete(:singleton) || false
-					@primary_key = options.delete(:primary_key) || "id"
-					@parent_key = options.delete(:parent_key) || "parent_id"
-					@content_type = options.delete(:content_type) || APPLICATION_JSON
-					if parent
-						@parent = parent
-						@path = [':d', @path].join('/') unless bare
-					end
-				end
-								
-				def list(&block)
-					@list = block if block
-					@list || ->(_){raise NotImplementedError, "list"}
-				end
-				
-				def one(&block)
-					@one = block if block
-					@one || ->(_){raise NotImplementedError, "one"}
-				end
-				
-				def save(&block)
-					@save = block if block
-					@save || ->(_){raise NotImplementedError, "save"}
-				end
-				
-				def delete(&block)
-					@delete = block if block
-					@content_type = nil
-					@delete || ->(_){raise NotImplementedError, "delete"}
-				end
-				
-				def serialize(&block)
-					@serialize = block if block
-					@serialize || ->(obj){obj.is_a?(String) ? obj : obj.send(:to_json)}
-				end
-				
-				def routes(*routes)
-					routes! if @routes
-					yield if block_given?
-					@routes = routes
-				end
-				
-				def permit(*permitted)
-					@permitted = permitted
-				end
-					
-				def routes!
-					unless @routes
-						@routes = SINGLETON_ROUTES.dup
-						@routes << :index unless @singleton
-					end
-					@routes.each { |route| @request.send(route) }
-				end
-				
-				POST_BODY  = 'rack.input'.freeze
-				FORM_INPUT = 'rack.request.form_input'.freeze
-				FORM_HASH  = 'rack.request.form_hash'.freeze
+        def perform_wrapped(method, args, &blk)
+          if respond_to? :"around_#{method}"
+            send :"around_#{method}", args, &blk
+          else
+            blk.call(args)
+          end
+        end
+        
+        def perform(method, id = nil)
+          begin
+            args = self.arguments(method, id)
+            perform_wrapped(method, args) do |args|
+              r = self.send(method).call(args)
+            end
+          rescue StandardError => e
+            raise if ENV['RACK_ENV'] == 'development'
+            @request.response.status = method === :save ? 422 : 404
+            @request.response.write e
+          end
+        end
+        
+        protected
+        
+        def arguments(method, id)
+          args = if method === :save
+            form = Rack::Request::FORM_DATA_MEDIA_TYPES.include?(@request.media_type)
+            permitted_args(form ? @request.POST : JSON.parse(@request.body.read))
+          else
+            symbolize_keys @request.GET
+          end
+          args.merge!(@primary_key.to_sym => id) if id
+          args.merge!(@parent_key.to_sym => @captures[0]) if @captures
+          args
+        end
 
-				
-				def perform(method, id = nil)
-					begin
-						args = self.arguments(method)
-						args.merge!(@primary_key.to_sym => id) if id
-						args.merge!(@parent_key.to_sym => @captures[0]) if @captures
-						self.send(method).call(args)
-					rescue StandardError => e
-						raise if ENV['RACK_ENV'] == 'development'
-						@request.response.status = method === :save ? 422 : 404
-						@request.response.write e
-					end
-				end
-				
-				protected
-				
-				def arguments(method)
-					if method === :save
-						args = if Rack::Request::FORM_DATA_MEDIA_TYPES.include?(@request.media_type)
-							@request.POST
-						else
-							JSON.parse(@request.body.read)
-						end
-						permitted_args args
-					else
-						symbolize_keys @request.GET
-					end
-				end
+        private
+        
+        def traverse_options(option_chain)
+          reverse_chain = option_chain.reverse
+          OPTIONS.each_pair do |key, default|
+            ivar = "@#{key}"
+            options = reverse_chain.find do |opts|
+              opts[key]
+            end
+            self.instance_variable_set(ivar, (options && options[key]) || default)
+          end
+          if @wrapper
+            raise ":wrapper should be a module" unless @wrapper.is_a? Module
+            self.extend @wrapper
+          end
+          if @serializer
+            raise ":serializer should respond to :serialize" unless @serializer.respond_to?(:serialize)
+            @serialize = ->(res){@serializer.serialize(res)}
+          end
+        end
+        
+        def symbolize_keys(args)
+          _args = {}
+          args.each do |k,v|
+            v = symbolize_keys(v) if v.is_a?(Hash)
+            _args[k.to_sym] = v
+          end
+          _args
+        end
+        
+        def permitted_args(args, keypath = [])
+          permitted = nil
+          case args
+          when Hash
+            permitted = Hash.new
+            args.each_pair do |k,v|
+              keypath << k.to_sym
+              if permitted?(keypath)
+                value = permitted_args(v, keypath)
+                permitted[k.to_sym] = value if value
+              end
+              keypath.pop
+            end
+          else
+            permitted = args if permitted?(keypath)
+          end
+          permitted
+        end
+        
+        def permitted?(keypath)
+          return false unless @permitted
+          permitted = @permitted
+          find_key = ->(items, key){
+            items.find do |item|
+              case item
+              when Hash
+                !!item.keys.index(key)
+              when Symbol
+                item === key
+              end
+            end
+          }
+          keypath.each do |key|
+            found = find_key.call(permitted, key)
+            permitted = found.is_a?(Hash) ? found.values.flatten : []
+            return false unless found
+          end
+        end
+      
+      end
+            
+      module RequestMethods
+        
+        def api(options={}, &block)
+          extract_resource_options options
+          path = options.delete(:path) || 'api'
+          subdomain = options.delete(:subdomain)
+          options.merge!(host: /\A#{Regexp.escape(subdomain)}\./) if subdomain
+          path = true if path.nil? or path.empty?
+          on(path, options, &block)
+        end
 
-				private
-				
-				def symbolize_keys(args)
-					_args = {}
-					args.each do |k,v|
-						v = symbolize_keys(v) if v.is_a?(Hash)
-						_args[k.to_sym] = v
-					end
-					_args
-				end
-				
-				def permitted_args(args, keypath = [])
-					permitted = nil
-					case args
-					when Hash
-						permitted = Hash.new
-						args.each_pair do |k,v|
-							keypath << k.to_sym
-							if permitted?(keypath)
-								value = permitted_args(v, keypath)
-								permitted[k.to_sym] = value if value
-							end
-							keypath.pop
-						end
-					else
-						permitted = args if permitted?(keypath)
-					end
-					permitted
-				end
-				
-				def permitted?(keypath)
-					return false unless @permitted
-					permitted = @permitted
-					find_key = ->(items, key){
-						items.find do |item|
-							case item
-							when Hash
-								!!item.keys.index(key)
-							when Symbol
-								item === key
-							end
-						end
-					}
-					keypath.each do |key|
-						found = find_key.call(permitted, key)
-						permitted = found.is_a?(Hash) ? found.values.flatten : []
-						return false unless found
-					end
-				end
-			
-			end
-			
-			module RequestMethods
-				
-				def api(options={}, &block)
-					path = options.delete(:path) || 'api'
-					subdomain = options.delete(:subdomain)
-					options.merge!(host: /\A#{Regexp.escape(subdomain)}\./) if subdomain
-					path = true if path.nil? or path.empty?
-					on(path, options, &block)
-				end
+        def version(version, options={}, &block)
+          extract_resource_options options
+          on("v#{version}", options, &block)
+        end
 
-				def version(version, &block)
-			  		on("v#{version}", &block)
-				end
+        def resource(path, options={})
+          extract_resource_options options
+          @resource = Resource.new(path, self, @resource, @resource_options)
+          on(@resource.path, options) do
+            roda_class.symbol_matcher(:id, @resource.id_pattern)
+            @resource.captures = captures.dup unless captures.empty?
+            yield @resource
+            @resource.routes!
+            response.status = 404
+          end
+          @resource_options.pop
+          @resource = @resource.parent
+        end
 
-				def resource(path, options={})
-					@resource = Resource.new(path, self, @resource, options)
-					on(@resource.path, options) do
-						@resource.captures = captures.dup unless captures.empty?
-						yield @resource
-					 	@resource.routes!
-						response.status = 404
-				  end
-				 	@resource = @resource.parent
-				end
+        def index(options={}, &block)
+          block ||= ->{ @resource.perform(:list) }
+          get(['', true], options, &block)
+        end
 
-			  def index(options={}, &block)
-				  block ||= ->{ @resource.perform(:list) }
-					get(['', true], options, &block)
-			  end
+        def show(options={}, &block)
+          block ||= default_block(:one)
+          get(_path, options, &block)
+        end
 
-			  def show(options={}, &block)
-				  block ||= default_block(:one)
-					get(_path, options, &block)
-			  end
+        def create(options={}, &block)
+          block ||= ->(){@resource.perform(:save)}
+          post(['', true], options) do
+            response.status = 201
+            block.call(*captures) if block
+          end
+        end
 
-			  def create(options={}, &block)
-				 	block ||= ->{@resource.perform(:save)}
-					post(["", true], options) do
-						response.status = 201
-						block.call(*captures) if block
-					end
-			  end
+        def update(options={}, &block)
+          block ||= default_block(:save)
+          options.merge!(method: [:put, :patch])
+          is(_path, options, &block)
+        end
 
-			  def update(options={}, &block)
-					block ||= default_block(:save)
-				  options.merge!(method: [:put, :patch])
-					is(_path, options, &block)
-			  end
+        def destroy(options={}, &block)
+          block ||= default_block(:delete)
+          delete(_path, options) do
+            response.status = 204
+            block.call(*captures) if block
+          end
+        end
 
-			  def destroy(options={}, &block)
-					block ||= default_block(:delete)
-					delete(_path, options) do
-						response.status = 204
-						block.call(*captures) if block
-					end
-			  end
+        def edit(options={}, &block)
+          block ||= default_block(:one)
+          get(_path('edit'), options, &block)
+        end
 
-			  def edit(options={}, &block)
-					block ||= default_block(:one)
-					get(_path("edit"), options, &block)
-			  end
+        def new(options={}, &block)
+          block ||= ->{@resource.perform(:one, "new")}
+          get('new', options, &block)
+        end
+        
+        private
+        
+        def extract_resource_options(options)
+          @resource_options ||= []
+          opts = {}
+          (Resource::OPTIONS.keys & options.keys).each do |key|
+            opts[key] = options.delete(key)
+          end
+          @resource_options << opts
+        end
+        
+        def _path(path=nil)
+          if @resource and @resource.singleton
+            path = ['', true] unless path
+          else
+            path = [':id', path].compact.join("/")
+          end
+          path
+        end
+        
+        def default_block(method)
+          if @resource.singleton
+            ->(){@resource.perform(method)}
+          else
+            ->(id){@resource.perform(method, id)}
+          end
+        end
+        
+        CONTENT_TYPE = 'Content-Type'.freeze
 
-			  def new(options={}, &block)
-				  block ||= ->{@resource.perform(:one, "new")}
-					get("new", options, &block)
-			  end
-				
-			  private
-			  
-			  def _path(path=nil)
-				  if @resource and @resource.singleton
-						path = ["", true] unless path
-					else
-						path = [":d", path].compact.join("/")
-					end
-					path
-				end
-				
-				def default_block(method)
-					if @resource.singleton
-						->(){@resource.perform(method)}
-					else
-						->(id){@resource.perform(method, id)}
-					end
-				end
-			  
-			  CONTENT_TYPE = 'Content-Type'.freeze
+        def block_result_body(result)
+          if result && @resource
+              response[CONTENT_TYPE] = @resource.content_type
+              @resource.serialize.call(result)
+            else
+              super
+          end
+        end
+        
+      end
+    end
+    
+    register_plugin(:rest_api, RestApi)
 
-			  def block_result_body(result)
-				  if result && @resource
-				  		response[CONTENT_TYPE] = @resource.content_type
-				  		@resource.serialize.call(result)
-				  	else
-					  	super
-					end
-			  end
-			  
-			end
-		end
-
-		register_plugin(:rest_api, RestApi)
-
-	end
+  end
 end