grape 0.4.1 → 0.5.0

data/Rakefile

@@ -28,16 +28,32 @@ begin
   namespace :doc do
     YARD::Rake::YardocTask.new(:pages) do |t|
       t.files   = DOC_FILES
-      t.options = ['-o', '../grape.doc']
+      t.options = ['-o', '../grape.doc/docs']
     end
 
     namespace :pages do
+
+      desc "Check out gh-pages."
+      task :checkout do
+        dir = File.dirname(__FILE__) + '/../grape.doc'
+        unless Dir.exist?(dir)
+          Dir.mkdir(dir)
+          Dir.chdir(dir) do
+            system("git init")
+            system("git remote add origin git@github.com:intridea/grape.git")
+            system("git pull")
+            system("git checkout gh-pages")
+          end
+        end
+      end
+
       desc 'Generate and publish YARD docs to GitHub pages.'
-      task :publish => ['doc:pages'] do
+      task :publish => ['doc:pages:checkout', 'doc:pages'] do
         Dir.chdir(File.dirname(__FILE__) + '/../grape.doc') do
+          system("git checkout gh-pages")
           system("git add .")
           system("git add -u")
-          system("git commit -m 'Generating docs for version #{version}.'")
+          system("git commit -m 'Generating docs for version #{Grape::VERSION}.'")
           system("git push origin gh-pages")
         end
       end

data/lib/grape.rb

@@ -9,6 +9,7 @@ require 'hashie'
 require 'active_support/core_ext/hash/indifferent_access'
 require 'active_support/ordered_hash'
 require 'active_support/core_ext/object/conversions'
+require 'active_support/core_ext/array/extract_options'
 require 'grape/util/deep_merge'
 require 'grape/util/content_types'
 require 'multi_json'
@@ -25,6 +26,7 @@ module Grape
   autoload :Namespace,           'grape/namespace'
   autoload :Cookies,             'grape/cookies'
   autoload :Validations,         'grape/validations'
+  autoload :Request,             'grape/http/request'
 
   module Exceptions
     autoload :Base,                           'grape/exceptions/base'
@@ -73,9 +75,10 @@ module Grape
     end
 
     module Versioner
-      autoload :Path,           'grape/middleware/versioner/path'
-      autoload :Header,         'grape/middleware/versioner/header'
-      autoload :Param,          'grape/middleware/versioner/param'
+      autoload :Path,                 'grape/middleware/versioner/path'
+      autoload :Header,               'grape/middleware/versioner/header'
+      autoload :Param,                'grape/middleware/versioner/param'
+      autoload :AcceptVersionHeader,  'grape/middleware/versioner/accept_version_header'
     end
   end
 

data/lib/grape/api.rb

@@ -370,6 +370,17 @@ module Grape
         end
       end
 
+      # Thie method allows you to quickly define a parameter route segment
+      # in your API.
+      #
+      # @param param [Symbol] The name of the parameter you wish to declare.
+      # @option options [Regexp] You may supply a regular expression that the declared parameter must meet.
+      def route_param(param, options = {}, &block)
+        options = options.dup
+        options[:requirements] = { param.to_sym => options[:requirements] } if options[:requirements].is_a?(Regexp)
+        namespace(":#{param}", options, &block)
+      end
+
       alias_method :group, :namespace
       alias_method :resource, :namespace
       alias_method :resources, :namespace
@@ -410,6 +421,12 @@ module Grape
         @versions ||= []
       end
 
+      def cascade(value = nil)
+        value.nil? ? 
+          (settings.has_key?(:cascade) ? !! settings[:cascade] : true) :
+          set(:cascade, value)
+      end
+
       protected
 
       def prepare_routes
@@ -443,7 +460,10 @@ module Grape
 
       def inherit_settings(other_stack)
         settings.prepend other_stack
-        endpoints.each{|e| e.settings.prepend(other_stack)}
+        endpoints.each do |e|
+          e.settings.prepend(other_stack)
+          e.options[:app].inherit_settings(other_stack) if e.options[:app].respond_to?(:inherit_settings, true)
+        end
       end
     end
 
@@ -471,8 +491,9 @@ module Grape
     # errors from reaching upstream. This is effectivelly done by unsetting
     # X-Cascade. Default :cascade is true.
     def cascade?
-      cascade = ((self.class.settings || {})[:version_options] || {})[:cascade]
-      cascade.nil? ? true : cascade
+      return !! self.class.settings[:cascade] if self.class.settings.has_key?(:cascade)
+      return !! self.class.settings[:version_options][:cascade] if self.class.settings[:version_options] && self.class.settings[:version_options].has_key?(:cascade)
+      true
     end
 
     reset!

data/lib/grape/endpoint.rb

@@ -169,9 +169,7 @@ module Grape
     # The parameters passed into the request as
     # well as parsed from URL segments.
     def params
-      @params ||= Hashie::Mash.new.
-        deep_merge(request.params).
-        deep_merge(env['rack.routing_args'] || {})
+      @params ||= @request.params
     end
 
     # A filtering method that will return a hash
@@ -180,20 +178,35 @@ module Grape
     #
     # @param params [Hash] The initial hash to filter. Usually this will just be `params`
     # @param options [Hash] Can pass `:include_missing` and `:stringify` options.
-    def declared(params, options = {})
+    def declared(params, options = {}, declared_params = settings[:declared_params])
       options[:include_missing] = true unless options.key?(:include_missing)
 
-      unless settings[:declared_params]
+      unless declared_params
         raise ArgumentError, "Tried to filter for declared parameters but none exist."
       end
 
-      settings[:declared_params].inject({}){|h,k|
-        output_key = options[:stringify] ? k.to_s : k.to_sym
-        if params.key?(output_key) || options[:include_missing]
-          h[output_key] = params[k]
+      if params.is_a? Array
+        params.map do |param|
+          declared(param || {}, options, declared_params)
         end
-        h
-      }
+      else
+        declared_params.inject({}) do |hash, key|
+          key = { key => nil } unless key.is_a? Hash
+
+          key.each_pair do |parent, children|
+            output_key = options[:stringify] ? parent.to_s : parent.to_sym
+            if params.key?(parent) || options[:include_missing]
+              hash[output_key] = if children
+                declared(params[parent] || {}, options, Array(children))
+              else
+                params[parent]
+              end
+            end
+          end
+
+          hash
+        end
+      end
     end
 
     # The API version as specified in the URL.
@@ -257,13 +270,7 @@ module Grape
 
     # Retrieves all available request headers.
     def headers
-      @headers ||= @env.dup.inject({}) { |h, (k, v)|
-        if k.start_with? 'HTTP_'
-          k = k[5..-1].gsub('_', '-').downcase.gsub(/^.|[-_\s]./) { |x| x.upcase }
-          h[k] = v
-        end
-        h
-      }
+      @headers ||= @request.headers
     end
 
     # Set response content-type
@@ -316,7 +323,13 @@ module Grape
     #       :with => API::Entities::User,
     #       :admin => current_user.admin?
     #   end
-    def present(object, options = {})
+    def present(*args)
+      options = args.count > 1 ? args.extract_options! : {}
+      key, object = if args.count == 2 && args.first.is_a?(Symbol)
+                      args
+                    else
+                      [nil, args.first]
+                    end
       entity_class = options.delete(:with)
 
       # auto-detect the entity from the first object in the collection
@@ -339,6 +352,7 @@ module Grape
       end
 
       representation = { root => representation } if root
+      representation = (@body || {}).merge({key => representation}) if key
       body representation
     end
 
@@ -369,7 +383,7 @@ module Grape
     def run(env)
       @env = env
       @header = {}
-      @request = Rack::Request.new(@env)
+      @request = Grape::Request.new(@env)
 
       self.extend helpers
       cookies.read(@request)

data/lib/grape/http/request.rb

@@ -0,0 +1,28 @@
+module Grape
+  class Request < Rack::Request
+
+    def params
+      @env['grape.request.params'] ||= begin
+        params = Hashie::Mash.new(super)
+        if env['rack.routing_args']
+          args = env['rack.routing_args'].dup
+          # preserve version from query string parameters
+          args.delete(:version)
+          params.deep_merge!(args)
+        end
+        params
+      end
+    end
+
+    def headers
+      @env['grape.request.headers'] ||= @env.dup.inject({}) { |h, (k, v)|
+        if k.to_s.start_with? 'HTTP_'
+          k = k[5..-1].gsub('_', '-').downcase.gsub(/^.|[-_\s]./) { |x| x.upcase }
+          h[k] = v
+        end
+        h
+      }
+    end
+
+  end
+end

data/lib/grape/middleware/base.rb

@@ -34,7 +34,7 @@ module Grape
       def after; end
 
       def request
-        Rack::Request.new(self.env)
+        Grape::Request.new(self.env)
       end
 
       def response

data/lib/grape/middleware/filter.rb

@@ -3,7 +3,7 @@ module Grape
     # This is a simple middleware for adding before and after filters
     # to Grape APIs. It is used like so:
     #
-    #     use Grape::Middleware::Filter, :before => lambda{ do_something }, after: => lambda{ do_something }
+    #     use Grape::Middleware::Filter, :before => lambda{ do_something }, :after => lambda{ do_something }
     class Filter < Base
       def before
         app.instance_eval &options[:before] if options[:before]

data/lib/grape/middleware/formatter.rb

@@ -23,12 +23,14 @@ module Grape
 
       def after
         status, headers, bodies = *@app_response
-        formatter = Grape::Formatter::Base.formatter_for env['api.format'], options
+        # allow content-type to be explicitly overwritten
+        api_format = mime_types[headers["Content-Type"]] || env['api.format']
+        formatter = Grape::Formatter::Base.formatter_for api_format, options
         begin
           bodymap = bodies.collect do |body|
             formatter.call body, env
           end
-        rescue Exception => e
+        rescue Grape::Exceptions::InvalidFormatter => e
           throw :error, :status => 500, :message => e.message
         end
         headers['Content-Type'] = content_type_for(env['api.format']) unless headers['Content-Type']
@@ -39,37 +41,46 @@ module Grape
 
         # store read input in env['api.request.input']
         def read_body_input
-          if (request.post? || request.put? || request.patch?) && (! request.form_data?) && (! request.parseable_data?) && (request.content_length.to_i > 0)
-            if env['rack.input'] && (body = (env['api.request.input'] = env['rack.input'].read)).length > 0
-              read_rack_input body
+          if (request.post? || request.put? || request.patch?) &&
+            (! request.form_data? || ! request.media_type) &&
+            (! request.parseable_data?) &&
+            (request.content_length.to_i > 0 || request.env['HTTP_TRANSFER_ENCODING'] == 'chunked')
+
+            if (input = env['rack.input'])
+              input.rewind
+              body = env['api.request.input'] = input.read
+              begin
+                read_rack_input(body) if body && body.length > 0
+              ensure
+                input.rewind
+              end
             end
           end
         end
 
         # store parsed input in env['api.request.body']
         def read_rack_input(body)
-          begin
-            fmt = mime_types[request.media_type] if request.media_type
-            if content_type_for(fmt)
-              parser = Grape::Parser::Base.parser_for fmt, options
-              if parser
-                begin
-                  body = (env['api.request.body'] = parser.call(body, env))
-                  if body.is_a?(Hash)
-                    env['rack.request.form_hash'] = env['rack.request.form_hash'] ? 
-                      env['rack.request.form_hash'].merge(body) : 
-                      body
-                  end
+          fmt = mime_types[request.media_type] if request.media_type
+          fmt ||= options[:default_format]
+          if content_type_for(fmt)
+            parser = Grape::Parser::Base.parser_for fmt, options
+            if parser
+              begin
+                body = (env['api.request.body'] = parser.call(body, env))
+                if body.is_a?(Hash)
+                  env['rack.request.form_hash'] = env['rack.request.form_hash'] ?
+                    env['rack.request.form_hash'].merge(body) :
+                    body
                   env['rack.request.form_input'] = env['rack.input']
-                rescue Exception => e
-                  throw :error, :status => 400, :message => e.message
                 end
+              rescue Exception => e
+                throw :error, :status => 400, :message => e.message
               end
             else
-              throw :error, :status => 406, :message => "The requested content-type '#{request.media_type}' is not supported."
+              env['api.request.body'] = body
             end
-          ensure
-            env['rack.input'].rewind
+          else
+            throw :error, :status => 406, :message => "The requested content-type '#{request.media_type}' is not supported."
           end
         end
 

data/lib/grape/middleware/versioner.rb

@@ -21,6 +21,8 @@ module Grape
           Header
         when :param
           Param
+        when :accept_version_header
+          AcceptVersionHeader
         else
           raise Grape::Exceptions::InvalidVersionerOption.new(strategy)
         end

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

@@ -0,0 +1,67 @@
+require 'grape/middleware/base'
+
+module Grape
+  module Middleware
+    module Versioner
+      # This middleware sets various version related rack environment variables
+      # based on the HTTP Accept-Version header
+      #
+      # Example: For request header
+      #    Accept-Version: v1
+      #
+      # The following rack env variables are set:
+      #
+      #    env['api.version]  => 'v1'
+      #
+      # 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.
+      class AcceptVersionHeader < Base
+
+        def before
+          potential_version = (env['HTTP_ACCEPT_VERSION'] || '').strip
+
+          if strict?
+            # If no Accept-Version header:
+            if potential_version.empty?
+              throw :error, :status => 406, :headers => error_headers, :message => 'Accept-Version header must be set.'
+            end
+          end
+
+          unless potential_version.empty?
+            # If the requested version is not supported:
+            if !versions.any? { |v| v.to_s == potential_version }
+              throw :error, :status => 406, :headers => error_headers, :message => 'The requested version is not supported.'
+            end
+
+            env['api.version'] = potential_version
+          end
+        end
+
+      private
+
+        def versions
+          options[:versions] || []
+        end
+
+        def strict?
+          options[:version_options] && options[:version_options][:strict]
+        end
+
+        # By default those errors contain an `X-Cascade` header set to `pass`, which allows nesting and stacking
+        # of routes (see [Rack::Mount](https://github.com/josh/rack-mount) for more information). To prevent
+        # this behavior, and not add the `X-Cascade` header, one can set the `:cascade` option to `false`.
+        def cascade?
+          options[:version_options] && options[:version_options].has_key?(:cascade) ? 
+            !! options[:version_options][:cascade] : 
+            true
+        end
+
+        def error_headers
+          cascade? ? { 'X-Cascade' => 'pass' } : {}
+        end
+
+      end
+    end
+  end
+end

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

@@ -99,7 +99,9 @@ module Grape
         # of routes (see [Rack::Mount](https://github.com/josh/rack-mount) for more information). To prevent
         # this behavior, and not add the `X-Cascade` header, one can set the `:cascade` option to `false`.
         def cascade?
-          options[:version_options] && (options[:version_options].has_key?(:cascade) ? options[:version_options][:cascade] : true)
+          options[:version_options] && options[:version_options].has_key?(:cascade) ? 
+            !! options[:version_options][:cascade] : 
+            true
         end
 
         def error_headers

data/lib/grape/util/hash_stack.rb

@@ -42,6 +42,17 @@ module Grape
       end
       alias_method :[], :get
 
+      # Looks through the stack for the first frame that matches :key
+      #
+      # @param key [Symbol] key to look for in hash frames
+      # @return true if key exists, false otherwise
+      def has_key?(key)
+        (@stack.length - 1).downto(0).each do |i|
+          return true if @stack[i].key? key
+        end
+        false
+      end
+
       # Replace a value on the top hash of the stack.
       #
       # @param key [Symbol] The key to set.