grape 0.2.3 → 0.2.4

data/Rakefile

@@ -19,18 +19,16 @@ task :default => :spec
 
 begin
   require 'yard'
-  YARD_OPTS = ['-m', 'markdown', '-M', 'maruku']
   DOC_FILES = ['lib/**/*.rb', 'README.markdown']
   
   YARD::Rake::YardocTask.new(:doc) do |t|
     t.files   = DOC_FILES
-    t.options = YARD_OPTS
   end
   
   namespace :doc do
     YARD::Rake::YardocTask.new(:pages) do |t|
       t.files   = DOC_FILES
-      t.options = YARD_OPTS + ['-o', '../grape.doc']
+      t.options = ['-o', '../grape.doc']
     end
     
     namespace :pages do

data/lib/grape.rb

@@ -4,8 +4,6 @@ require 'rack/builder'
 module Grape
   autoload :API,                 'grape/api'
   autoload :Endpoint,            'grape/endpoint'
-  autoload :MiddlewareStack,     'grape/middleware_stack'
-  autoload :Client,              'grape/client'
   autoload :Route,               'grape/route'
   autoload :Entity,              'grape/entity'
   autoload :Cookies,             'grape/cookies'
@@ -39,7 +37,6 @@ module Grape
 
   module Middleware
     autoload :Base,              'grape/middleware/base'
-    autoload :Prefixer,          'grape/middleware/prefixer'
     autoload :Versioner,         'grape/middleware/versioner'
     autoload :Formatter,         'grape/middleware/formatter'
     autoload :Error,             'grape/middleware/error'

data/lib/grape/api.rb

@@ -125,9 +125,14 @@ module Grape
       end
 
       # Specify the format for the API's serializers.
-      # May be `:json` or `:txt`.
+      # May be `:json`, `:xml`, `:txt`, etc.
       def format(new_format = nil)
-        new_format ? set(:format, new_format.to_sym) : settings[:format]
+        if new_format
+          set(:format, new_format.to_sym)
+          set(:default_error_formatter, Grape::ErrorFormatter::Base.formatter_for(new_format, {}))
+        else
+          settings[:format]
+        end
       end
 
       # Specify a custom formatter for a content-type.
@@ -135,6 +140,11 @@ module Grape
         settings.imbue(:formatters, content_type.to_sym => new_formatter)
       end
 
+      # Specify a default error formatter.
+      def default_error_formatter(new_formatter = nil)
+        new_formatter ? set(:default_error_formatter, new_formatter) : settings[:default_error_formatter]
+      end
+
       def error_formatter(format, new_formatter)
         settings.imbue(:error_formatters, format.to_sym => new_formatter)
       end
@@ -209,10 +219,11 @@ module Grape
       # When called without a block, all known helpers within this scope
       # are included.
       #
-      # @param mod [Module] optional module of methods to include
-      # @param &block [Block] optional block of methods to include
+      # @param [Module] new_mod optional module of methods to include
+      # @param [Block] block optional block of methods to include
       #
       # @example Define some helpers.
+      #
       #     class ExampleAPI < Grape::API
       #       helpers do
       #         def current_user
@@ -220,6 +231,7 @@ module Grape
       #         end
       #       end
       #     end
+      #
       def helpers(new_mod = nil, &block)
         if block_given? || new_mod
           mod = settings.peek[:helpers] || Module.new

data/lib/grape/cookies.rb

@@ -1,41 +1,43 @@
 module Grape
   class Cookies
 
-      def initialize
-        @cookies = {}
-        @send_cookies = {}
-      end
+    def initialize
+      @cookies = {}
+      @send_cookies = {}
+    end
 
-      def read(request)
-        request.cookies.each do |name, value|
-          @cookies[name.to_sym] = value
-        end
+    def read(request)
+      request.cookies.each do |name, value|
+        @cookies[name.to_s] = value
       end
+    end
 
-      def write(header)
-        @cookies.select { |key, value|
-            @send_cookies[key.to_sym] == true
-        }.each { |name, value|
-          Rack::Utils.set_cookie_header!(
-            header, name, value.instance_of?(Hash) ? value : { :value => value })
-        }
-      end
+    def write(header)
+      @cookies.select { |key, value|
+        @send_cookies[key] == true
+      }.each { |name, value|
+        cookie_value = value.is_a?(Hash) ? value : { :value => value }
+        Rack::Utils.set_cookie_header! header, name, cookie_value
+      }
+    end
 
-      def [](name)
-        @cookies[name]
-      end
+    def [](name)
+      @cookies[name.to_s]
+    end
 
-      def []=(name, value)
-        @cookies[name.to_sym] = value
-        @send_cookies[name.to_sym] = true
-      end
+    def []=(name, value)
+      @cookies[name.to_s] = value
+      @send_cookies[name.to_s] = true
+    end
 
-      def each(&block)
-        @cookies.each(&block)
-      end
+    def each(&block)
+      @cookies.each(&block)
+    end
 
-      def delete(name)
-        self.[]=(name, { :value => 'deleted', :expires => Time.at(0) })
-      end
+    def delete(name, opts = {})
+      options = opts.merge({ :value => 'deleted', :expires => Time.at(0) })
+      self.[]=(name, options)
     end
-end
+
+  end
+end

data/lib/grape/endpoint.rb

@@ -6,9 +6,9 @@ module Grape
   # An Endpoint is the proxy scope in which all routing
   # blocks are executed. In other words, any methods
   # on the instance level of this class may be called
-  # from inside a `get`, `post`, etc. block.
+  # from inside a `get`, `post`, etc.
   class Endpoint
-    attr_accessor :block, :options, :settings
+    attr_accessor :block, :source, :options, :settings
     attr_reader :env, :request
 
     class << self
@@ -40,6 +40,7 @@ module Grape
       @settings = settings
       if block_given?
         method_name = "#{options[:method]} #{settings.gather(:namespace).join( "/")} #{Array(options[:path]).join("/")}"
+        @source = block
         @block = self.class.generate_api_method(method_name, &block)
       end
       @options = options
@@ -55,12 +56,12 @@ module Grape
     end
 
     def routes
-      @routes ||= prepare_routes
+      @routes ||= endpoints ? endpoints.collect(&:routes).flatten : prepare_routes
     end
 
     def mount_in(route_set)
-      if options[:app] && options[:app].respond_to?(:endpoints)
-        options[:app].endpoints.each{|e| e.mount_in(route_set)}
+      if endpoints
+        endpoints.each{|e| e.mount_in(route_set)}
       else
         routes.each do |route|
           route_set.add_route(self, {
@@ -109,7 +110,7 @@ module Grape
 
     def prepare_path(path)
       parts = []
-      parts << settings[:root_prefix] if settings[:root_prefix]
+      parts << settings[:root_prefix].to_s.split("/") if settings[:root_prefix]
 
       uses_path_versioning = settings[:version] && settings[:version_options][:using] == :path
       namespace_is_empty = namespace && (namespace.to_s =~ /^\s*$/ || namespace.to_s == '/')
@@ -118,11 +119,12 @@ module Grape
       parts << ':version' if uses_path_versioning
       if !uses_path_versioning || (!namespace_is_empty || !path_is_empty)
         parts << namespace.to_s if namespace
-        parts << path.to_s if path && '/' != path
+        parts << path.to_s if path
         format_suffix = '(.:format)'
       else
         format_suffix = '(/.:format)'
       end
+      parts = parts.flatten.select { |part| part != '/' }
       Rack::Mount::Utils.normalize_path(parts.join('/') + format_suffix)
     end
 
@@ -186,9 +188,10 @@ module Grape
     # Pull out request body params if the content type matches and we're on a POST or PUT
     def body_params
       if ['POST', 'PUT'].include?(request.request_method.to_s.upcase) && request.content_length.to_i > 0
-        return case env['CONTENT_TYPE']
+        return @body_params ||=
+          case env['CONTENT_TYPE']
           when 'application/json'
-            MultiJson.decode(request.body.read)
+            MultiJson.load(request.body.read)
           when 'application/xml'
             MultiXml.parse(request.body.read)
           else
@@ -345,6 +348,16 @@ module Grape
 
     protected
 
+    # Return the collection of endpoints within this endpoint.
+    # This is the case when an Grape::API mounts another Grape::API.
+    def endpoints
+      if options[:app] && options[:app].respond_to?(:endpoints)
+        options[:app].endpoints
+      else
+        nil
+      end
+    end
+
     def run(env)
       @env = env
       @header = {}
@@ -377,18 +390,19 @@ module Grape
         :default_status => settings[:default_error_status] || 403,
         :rescue_all => settings[:rescue_all],
         :rescued_errors => aggregate_setting(:rescued_errors),
+        :default_error_formatter => settings[:default_error_formatter],
         :error_formatters => settings[:error_formatters],
         :rescue_options => settings[:rescue_options],
         :rescue_handlers => merged_setting(:rescue_handlers)
 
       b.use Rack::Auth::Basic, settings[:auth][:realm], &settings[:auth][:proc] if settings[:auth] && settings[:auth][:type] == :http_basic
       b.use Rack::Auth::Digest::MD5, settings[:auth][:realm], settings[:auth][:opaque], &settings[:auth][:proc] if settings[:auth] && settings[:auth][:type] == :http_digest
-      b.use Grape::Middleware::Prefixer, :prefix => settings[:root_prefix] if settings[:root_prefix]
 
       if settings[:version]
         b.use Grape::Middleware::Versioner.using(settings[:version_options][:using]), {
           :versions        => settings[:version],
-          :version_options => settings[:version_options]
+          :version_options => settings[:version_options],
+          :prefix          => settings[:root_prefix]
         }
       end
 

data/lib/grape/entity.rb

@@ -330,6 +330,11 @@ module Grape
 
     alias :as_json :serializable_hash
 
+    def to_json(options = {})
+      options = options.to_h if options && options.respond_to?(:to_h)
+      MultiJson.dump(serializable_hash(options))
+    end
+
     protected
 
     def key_for(attribute)

data/lib/grape/error_formatter/base.rb

@@ -5,6 +5,7 @@ module Grape
       class << self
 
         FORMATTERS = {
+          :serializable_hash => Grape::ErrorFormatter::Json,
           :json => Grape::ErrorFormatter::Json,
           :txt => Grape::ErrorFormatter::Txt,
           :xml => Grape::ErrorFormatter::Xml
@@ -18,7 +19,7 @@ module Grape
           spec = formatters(options)[api_format]
           case spec
           when nil
-            lambda { |message, backtrace, options| message }
+            options[:default_error_formatter] || Grape::ErrorFormatter::Txt
           when Symbol
             method(spec)
           else

data/lib/grape/middleware/base.rb

@@ -1,4 +1,5 @@
 require 'active_support/ordered_hash'
+require 'active_support/core_ext/hash/indifferent_access'
 require 'multi_json'
 require 'multi_xml'
 
@@ -24,7 +25,9 @@ module Grape
         @options = default_options.merge(options)
       end
 
-      def default_options; {} end
+      def default_options
+        {}
+      end
 
       def call(env)
         dup.call!(env)
@@ -53,12 +56,16 @@ module Grape
         Rack::Response.new(@app_response)
       end
 
+      def content_type_for(format)
+        HashWithIndifferentAccess.new(content_types)[format]
+      end
+
       def content_types
         options[:content_types] || CONTENT_TYPES
       end
 
       def content_type
-        content_types[env['api.format'] || options[:format]] || 'text/html'
+        content_type_for(env['api.format'] || options[:format]) || 'text/html'
       end
 
       def mime_types

data/lib/grape/middleware/error.rb

@@ -6,17 +6,17 @@ module Grape
     class Error < Base
 
       def default_options
-      {
-        :default_status => 403, # default status returned on error
-        :default_message => "",
-        :format => :txt,
-        :formatters => {},
-        :error_formatters => {},
-        :rescue_all => false, # true to rescue all exceptions
-        :rescue_options => { :backtrace => false }, # true to display backtrace
-        :rescue_handlers => {}, # rescue handler blocks
-        :rescued_errors => []
-      }
+        {
+          :default_status => 403, # default status returned on error
+          :default_message => "",
+          :format => :txt,
+          :formatters => {},
+          :error_formatters => {},
+          :rescue_all => false, # true to rescue all exceptions
+          :rescue_options => { :backtrace => false }, # true to display backtrace
+          :rescue_handlers => {}, # rescue handler blocks
+          :rescued_errors => []
+        }
       end
 
       def call!(env)

data/lib/grape/middleware/formatter.rb

@@ -18,7 +18,7 @@ module Grape
 
       def before
         fmt = format_from_extension || format_from_params || options[:format] || format_from_header || options[:default_format]
-        if content_types.key?(fmt)
+        if content_type_for(fmt)
           if !env['rack.input'].nil? and (body = env['rack.input'].read).strip.length != 0
             parser = Grape::Parser::Base.parser_for fmt, options
             unless parser.nil?
@@ -42,15 +42,18 @@ module Grape
         parts = request.path.split('.')
 
         if parts.size > 1
-          extension = parts.last.to_sym
-          return extension if content_types.key?(extension)
+          extension = parts.last
+          # avoid symbol memory leak on an unknown format
+          return extension.to_sym if content_type_for(extension)
         end
         nil
       end
 
       def format_from_params
         fmt = Rack::Utils.parse_nested_query(env['QUERY_STRING'])["format"]
-        fmt ? fmt.to_sym : nil
+        # avoid symbol memory leak on an unknown format
+        return fmt.to_sym if content_type_for(fmt)
+        fmt
       end
 
       def format_from_header
@@ -76,7 +79,7 @@ module Grape
         bodymap = bodies.collect do |body|
           formatter.call body, env
         end
-        headers['Content-Type'] = content_types[env['api.format']] unless headers['Content-Type']
+        headers['Content-Type'] = content_type_for(env['api.format']) unless headers['Content-Type']
         Rack::Response.new(bodymap, status, headers).to_a
       end
 

data/lib/grape/middleware/versioner/header.rb

@@ -19,11 +19,9 @@ module Grape
       #    env['api.version]  => 'v1'
       #    env['api.format]   => 'format'
       #
-      # If version does not match this route, then a 406 is throw with
+      # If version does not match this route, then a 406 is raised with
       # X-Cascade header to alert Rack::Mount to attempt the next matched
       # route.
-      #
-      # @throws [RuntimeError] if Accept header is invalid
       class Header < Base
 
         def before

data/lib/grape/middleware/versioner/path.rb

@@ -24,7 +24,14 @@ module Grape
         end
 
         def before
-          pieces = env['PATH_INFO'].split('/')
+          path = env['PATH_INFO'].dup
+
+          if prefix && path.index(prefix) == 0
+            path.sub!(prefix, '')
+            path = Rack::Mount::Utils.normalize_path(path)
+          end
+
+          pieces = path.split('/')
           potential_version = pieces[1]
           if potential_version =~ options[:pattern]
             if options[:versions] && !options[:versions].include?(potential_version)
@@ -33,9 +40,15 @@ module Grape
 
             truncated_path = "/#{pieces[2..-1].join('/')}"
             env['api.version'] = potential_version
-            env['PATH_INFO'] = truncated_path
           end
         end
+
+        private
+
+          def prefix
+            Rack::Mount::Utils.normalize_path(options[:prefix].to_s) if options[:prefix]
+          end
+
       end
     end
   end