grape 0.2.1.1 → 0.2.2

data/lib/grape/exceptions/validation_error.rb

@@ -0,0 +1,10 @@
+require 'grape/exceptions/base'
+
+class ValidationError < Grape::Exceptions::Base
+  attr_accessor :param
+
+  def initialize(args = {})
+    @param = args[:param].to_s if args.has_key? :param
+    super
+  end
+end

data/lib/grape/middleware/base.rb

@@ -1,3 +1,4 @@
+require 'active_support/ordered_hash'
 require 'multi_json'
 require 'multi_xml'
 
@@ -44,14 +45,14 @@ module Grape
 
 
       module Formats
-
-        CONTENT_TYPES = {
-          :xml => 'application/xml',
-          :json => 'application/json',
-          :atom => 'application/atom+xml',
-          :rss => 'application/rss+xml',
-          :txt => 'text/plain'
-        }
+        # Content types are listed in order of preference.
+        CONTENT_TYPES = ActiveSupport::OrderedHash[
+          :xml,  'application/xml',
+          :json, 'application/json',
+          :atom, 'application/atom+xml',
+          :rss,  'application/rss+xml',
+          :txt,  'text/plain',
+        ]
         FORMATTERS = {
           :json => :encode_json,
           :txt => :encode_txt,
@@ -70,10 +71,6 @@ module Grape
           PARSERS.merge(options[:parsers] || {})
         end
 
-        def content_type_for(format)
-          Hash.new(content_types)[format.to_sym]
-        end
-
         def content_types
           CONTENT_TYPES.merge(options[:content_types] || {})
         end
@@ -114,20 +111,32 @@ module Grape
           MultiJson.load(object)
         end
 
-        def encode_json(object)
-          return object if object.is_a?(String)
+        def serializable?(object)
+         object.respond_to?(:serializable_hash) ||
+           object.kind_of?(Array) && !object.map {|o| o.respond_to? :serializable_hash }.include?(false) ||
+           object.kind_of?(Hash)
+        end
 
+        def serialize(object)
           if object.respond_to? :serializable_hash
-            MultiJson.dump(object.serializable_hash)
+            object.serializable_hash
           elsif object.kind_of?(Array) && !object.map {|o| o.respond_to? :serializable_hash }.include?(false)
-            MultiJson.dump(object.map {|o| o.serializable_hash })
-          elsif object.respond_to? :to_json
-            object.to_json
+            object.map {|o| o.serializable_hash }
+          elsif object.kind_of?(Hash)
+            object.inject({}) { |h,(k,v)| h[k] = serialize(v); h }
           else
-            MultiJson.dump(object)
+            object
           end
         end
 
+        def encode_json(object)
+          return object if object.is_a?(String)
+          return MultiJson.dump(serialize(object)) if serializable?(object)
+          return object.to_json if object.respond_to?(:to_json)
+
+          MultiJson.dump(object)
+        end
+
         def encode_txt(object)
           object.respond_to?(:to_txt) ? object.to_txt : object.to_s
         end

data/lib/grape/middleware/error.rb

@@ -44,11 +44,19 @@ module Grape
             return @app.call(@env) 
           })
         rescue Exception => e
-          raise unless options[:rescue_all] || (options[:rescued_errors] || []).include?(e.class)
-          handler = options[:rescue_handlers][e.class] || options[:rescue_handlers][:all]
+          is_rescuable = rescuable?(e.class)
+          if e.is_a?(Grape::Exceptions::Base) && !is_rescuable
+            handler = lambda {|e| error_response(e) }
+          else
+            raise unless is_rescuable
+            handler = options[:rescue_handlers][e.class] || options[:rescue_handlers][:all]
+          end
           handler.nil? ? handle_error(e) : self.instance_exec(e, &handler)
         end
-        
+      end
+
+      def rescuable?(klass)
+        options[:rescue_all] || (options[:rescued_errors] || []).include?(klass)
       end
       
       def handle_error(e)

data/lib/grape/middleware/formatter.rb

@@ -19,29 +19,17 @@ module Grape
       end
 
       def before
-        fmt = format_from_extension || options[:format] || format_from_header || options[:default_format]
+        fmt = format_from_extension || format_from_params || options[:format] || format_from_header || options[:default_format]
         if content_types.key?(fmt)
           if !env['rack.input'].nil? and (body = env['rack.input'].read).strip.length != 0
             parser = parser_for fmt
             unless parser.nil?
               begin
-                fmt = mime_types[request.media_type] if request.media_type
-                if content_type_for(fmt)
-                  parser = parser_for fmt
-                  unless parser.nil?
-                    begin
-                      body = parser.call body
-                      env['rack.request.form_hash'] = !env['rack.request.form_hash'].nil? ? env['rack.request.form_hash'].merge(body) : body
-                      env['rack.request.form_input'] = env['rack.input']
-                    rescue
-                      # It's possible that it's just regular POST content -- just back off
-                    end
-                  end
-                else
-                  throw :error, :status => 406, :message => 'The requested content-type is not supported.'
-                end
-              ensure
-                env['rack.input'].rewind
+                body = parser.call(body)
+                env['rack.request.form_hash'] = !env['rack.request.form_hash'].nil? ? env['rack.request.form_hash'].merge(body) : body
+                env['rack.request.form_input'] = env['rack.input']
+              rescue
+                # It's possible that it's just regular POST content -- just back off
               end
             end
             env['rack.input'].rewind
@@ -62,6 +50,11 @@ module Grape
         nil
       end
 
+      def format_from_params
+        fmt = Rack::Utils.parse_nested_query(env['QUERY_STRING'])["format"]
+        fmt ? fmt.to_sym : nil
+      end
+
       def format_from_header
         mime_array.each do |t|
           if mime_types.key?(t)

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

@@ -1,4 +1,5 @@
 require 'grape/middleware/base'
+require 'rack/accept'
 
 module Grape
   module Middleware
@@ -21,37 +22,95 @@ module Grape
       # If version does not match this route, then a 406 is throw with
       # X-Cascade header to alert Rack::Mount to attempt the next matched
       # route.
+      #
+      # @throws [RuntimeError] if Accept header is invalid
       class Header < Base
+        include Formats
+
         def before
-          accept = env['HTTP_ACCEPT'] || ""
+          header = Rack::Accept::MediaType.new env['HTTP_ACCEPT']
 
-          if options[:version_options] && options[:version_options].keys.include?(:strict) && options[:version_options][:strict]
-            if (is_accept_header_valid?(accept))  && options[:version_options][:using] == :header
-              throw :error, :status => 406, :headers => {'X-Cascade' => 'pass'}, :message => "406 API Version Not Found"
+          if strict?
+            # If no Accept header:
+            if header.qvalues.empty?
+              throw :error, :status => 406, :headers => {'X-Cascade' => 'pass'}, :message => 'Accept header must be set'
+            end
+            # Remove any acceptable content types with ranges.
+            header.qvalues.reject! do |media_type,_|
+              Rack::Accept::Header.parse_media_type(media_type).find{|s| s == '*'}
+            end
+            # If all Accept headers included a range:
+            if header.qvalues.empty?
+              throw :error, :status => 406, :headers => {'X-Cascade' => 'pass'}, :message => 'Accept header must not contain ranges ("*")'
             end
           end
-          accept.strip.scan(/^(.+?)\/(.+?)$/) do |type, subtype|
+
+          media_type = header.best_of available_media_types
+
+          if media_type
+            type, subtype = Rack::Accept::Header.parse_media_type media_type
             env['api.type']    = type
             env['api.subtype'] = subtype
 
-            subtype.scan(/vnd\.(.+)?-(.+)?\+(.*)?/) do |vendor, version, format|
-              is_vendored = options[:version_options] && options[:version_options][:vendor]
-              is_vendored_match = is_vendored ? options[:version_options][:vendor] == vendor : true
+            if /\Avnd\.([a-z0-9*.]+)(?:-([a-z0-9*\-.]+))?(?:\+([a-z0-9*\-.+]+))?\z/ =~ subtype
+              env['api.vendor']  = $1
+              env['api.version'] = $2
+              env['api.format']  = $3  # weird that Grape::Middleware::Formatter also does this
+            end
+          # If none of the available content types are acceptable:
+          elsif strict?
+            throw :error, :status => 406, :headers => {'X-Cascade' => 'pass'}, :message => '406 Not Acceptable'
+          # If all acceptable content types specify a vendor or version that doesn't exist:
+          elsif header.values.all?{|media_type| has_vendor?(media_type) || has_version?(media_type)}
+            throw :error, :status => 406, :headers => {'X-Cascade' => 'pass'}, :message => 'API vendor or version not found'
+          end
+        end
 
-              if (options[:versions] && !options[:versions].include?(version)) || !is_vendored_match
-                throw :error, :status => 406, :headers => {'X-Cascade' => 'pass'}, :message => "406 API Version Not Found"
-              end
+      private
 
-              env['api.version'] = version
-              env['api.vendor']  = vendor
-              env['api.format']  = format  # weird that Grape::Middleware::Formatter also does this
+        def available_media_types
+          available_media_types = []
+
+          content_types.each do |extension,media_type|
+            versions.reverse.each do |version|
+              available_media_types += ["application/vnd.#{vendor}-#{version}+#{extension}", "application/vnd.#{vendor}-#{version}"]
             end
+            available_media_types << "application/vnd.#{vendor}+#{extension}"
+          end
+
+          available_media_types << "application/vnd.#{vendor}"
+
+          content_types.each do |_,media_type|
+            available_media_types << media_type
           end
+
+          available_media_types = available_media_types.flatten
+        end
+
+        def versions
+          options[:versions] || []
+        end
+
+        def vendor
+          options[:version_options] && options[:version_options][:vendor]
+        end
+
+        def strict?
+          options[:version_options] && options[:version_options][:strict]
+        end
+
+        # @param [String] media_type a content type
+        # @return [Boolean] whether the content type sets a vendor
+        def has_vendor?(media_type)
+          type, subtype = Rack::Accept::Header.parse_media_type media_type
+          subtype[/\Avnd\.[a-z0-9*.]+/]
         end
 
-        protected
-        def is_accept_header_valid?(header)
-          (header.strip =~ /application\/vnd\.(.+?)-(.+?)\+(.+?)/).nil?
+        # @param [String] media_type a content type
+        # @return [Boolean] whether the content type sets an API version
+        def has_version?(media_type)
+          type, subtype = Rack::Accept::Header.parse_media_type media_type
+          subtype[/\Avnd\.[a-z0-9*.]+-[a-z0-9*\-.]+/]
         end
       end
     end

data/lib/grape/util/deep_merge.rb

@@ -0,0 +1,23 @@
+class Hash
+  # deep_merge from rails
+  # activesupport/lib/active_support/core_ext/hash/deep_merge.rb
+  # Returns a new hash with +self+ and +other_hash+ merged recursively.
+  #
+  #   h1 = {:x => {:y => [4,5,6]}, :z => [7,8,9]}
+  #   h2 = {:x => {:y => [7,8,9]}, :z => "xyz"}
+  #
+  #   h1.deep_merge(h2) #=> { :x => {:y => [7, 8, 9]}, :z => "xyz" }
+  #   h2.deep_merge(h1) #=> { :x => {:y => [4, 5, 6]}, :z => [7, 8, 9] }
+  def deep_merge(other_hash)
+    dup.deep_merge!(other_hash)
+  end
+
+  # Same as +deep_merge+, but modifies +self+.
+  def deep_merge!(other_hash)
+    other_hash.each_pair do |k,v|
+      tv = self[k]
+      self[k] = tv.is_a?(Hash) && v.is_a?(Hash) ? tv.deep_merge(v) : v
+    end
+    self
+  end
+end

data/lib/grape/util/hash_stack.rb

@@ -18,7 +18,7 @@ module Grape
       end
 
       # Add a new hash to the top of the stack.
-      # 
+      #
       # @param hash [Hash] optional hash to be pushed. Defaults to empty hash
       # @return [HashStack]
       def push(hash = {})
@@ -31,7 +31,7 @@ module Grape
       end
 
       # Looks through the stack for the first frame that matches :key
-      # 
+      #
       # @param key [Symbol] key to look for in hash frames
       # @return value of given key after merging the stack
       def get(key)
@@ -52,7 +52,7 @@ module Grape
       alias_method :[]=, :set
 
       # Replace multiple values on the top hash of the stack.
-      # 
+      #
       # @param hash [Hash] Hash of values to be merged in.
       def update(hash)
         peek.merge!(hash)
@@ -83,6 +83,15 @@ module Grape
         self
       end
 
+      # Looks through the stack for all instances of a given key and returns
+      # them as a flat Array.
+      #
+      # @param key [Symbol] The key to gather
+      # @return [Array]
+      def gather(key)
+        stack.map{|s| s[key] }.flatten.compact.uniq
+      end
+
       def to_s
         @stack.to_s
       end

data/lib/grape/validations.rb

@@ -0,0 +1,202 @@
+require 'virtus'
+
+module Grape
+    
+  module Validations
+    
+    ##
+    # All validators must inherit from this class.
+    # 
+    class Validator
+      attr_reader :attrs
+
+      def initialize(attrs, options, required, scope)
+        @attrs = Array(attrs)
+        @required = required
+        @scope = scope
+
+        if options.is_a?(Hash) && !options.empty?
+          raise "unknown options: #{options.keys}"
+        end
+      end
+
+      def validate!(params)
+        params = @scope.params(params)
+
+        @attrs.each do |attr_name|
+          if @required || params.has_key?(attr_name)
+            validate_param!(attr_name, params)
+          end
+        end
+      end
+
+    private
+
+      def self.convert_to_short_name(klass)
+        ret = klass.name.gsub(/::/, '/').
+          gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+          gsub(/([a-z\d])([A-Z])/,'\1_\2').
+          tr("-", "_").
+          downcase
+        File.basename(ret, '_validator')
+      end
+    end
+
+    ##
+    # Base class for all validators taking only one param.
+    class SingleOptionValidator < Validator
+      def initialize(attrs, options, required, scope)
+        @option = options
+        super
+      end
+
+    end
+
+    # We define Validator::inherited here so SingleOptionValidator
+    # will not be considered a validator.
+    class Validator
+      def self.inherited(klass)
+        short_name = convert_to_short_name(klass)
+        Validations::register_validator(short_name, klass)
+      end
+    end
+    
+    class << self
+      attr_accessor :validators
+    end
+    
+    self.validators = {}
+    
+    def self.register_validator(short_name, klass)
+      validators[short_name] = klass
+    end
+    
+    class ParamsScope
+      attr_accessor :element, :parent
+
+      def initialize(api, element, parent, &block)
+        @element = element
+        @parent = parent
+        @api = api
+        instance_eval(&block)
+      end
+      
+      def requires(*attrs)
+        validations = {:presence => true}
+        if attrs.last.is_a?(Hash)
+          validations.merge!(attrs.pop)
+        end
+        
+        push_declared_params(attrs)
+        validates(attrs, validations)
+      end
+      
+      def optional(*attrs)
+        validations = {}
+        if attrs.last.is_a?(Hash)
+          validations.merge!(attrs.pop)
+        end
+
+        push_declared_params(attrs)
+        validates(attrs, validations)
+      end
+
+      def group(element, &block)
+        scope = ParamsScope.new(@api, element, self, &block)
+      end
+
+      def params(params)
+        params = @parent.params(params) if @parent
+        params = params[@element] || {} if @element
+        params
+      end
+
+      def full_name(name)
+        return "#{@parent.full_name(@element)}[#{name}]" if @parent
+        name.to_s
+      end
+
+    private
+      def validates(attrs, validations)
+        doc_attrs = { :required => validations.keys.include?(:presence) }
+        
+        # special case (type = coerce)
+        if validations[:type]
+          validations[:coerce] = validations.delete(:type)
+        end
+        
+        if coerce_type = validations[:coerce]
+          doc_attrs[:type] = coerce_type.to_s
+        end
+        
+        if desc = validations.delete(:desc)
+          doc_attrs[:desc] = desc
+        end
+
+        full_attrs = attrs.collect{ |name| { :name => name, :full_name => full_name(name)} }
+        @api.document_attribute(full_attrs, doc_attrs)
+
+        # Validate for presence before any other validators
+        if validations.has_key?(:presence) && validations[:presence]
+          validate('presence', validations[:presence], attrs, doc_attrs)
+        end
+
+        # Before we run the rest of the validators, lets handle
+        # whatever coercion so that we are working with correctly
+        # type casted values
+        if validations.has_key? :coerce
+          validate('coerce', validations[:coerce], attrs, doc_attrs)
+          validations.delete(:coerce)
+        end
+
+        validations.each do |type, options|
+          validate(type, options, attrs, doc_attrs)
+        end
+      end
+
+      def validate(type, options, attrs, doc_attrs)
+        validator_class = Validations::validators[type.to_s]
+
+        if validator_class
+          (@api.settings.peek[:validations] ||= []) << validator_class.new(attrs, options, doc_attrs[:required], self)
+        else
+          raise "unknown validator: #{type}"
+        end
+      end
+
+      def push_declared_params(attrs)
+        @api.settings.peek[:declared_params] ||= []
+        @api.settings[:declared_params] += attrs
+      end
+    end
+    
+    # This module is mixed into the API Class.
+    module ClassMethods
+      def reset_validations!
+        settings.peek[:declared_params] = []
+        settings.peek[:validations] = []
+      end
+      
+      def params(&block)
+        ParamsScope.new(self, nil, nil, &block)
+      end
+      
+      def document_attribute(names, opts)
+        @last_description ||= {}
+        @last_description[:params] ||= {}
+
+        Array(names).each do |name|
+          @last_description[:params][name[:name].to_s] ||= {}
+          @last_description[:params][name[:name].to_s].merge!(opts).merge!({:full_name => name[:full_name]})
+        end
+      end
+      
+    end
+    
+  end
+end
+
+# Load all defined validations.
+Dir[File.expand_path('../validations/*.rb', __FILE__)].each do |path|
+  require(path)
+end