grape 0.2.1.1 → 0.2.2

data/grape.gemspec

@@ -16,10 +16,13 @@ Gem::Specification.new do |s|
 
   s.add_runtime_dependency 'rack'
   s.add_runtime_dependency 'rack-mount'
+  s.add_runtime_dependency 'rack-accept'
+  s.add_runtime_dependency 'activesupport'
   # s.add_runtime_dependency 'rack-jsonp'
-  s.add_runtime_dependency 'multi_json'
-  s.add_runtime_dependency 'multi_xml', '>= 0.5.2'
+  s.add_runtime_dependency 'multi_json', '>= 1.3.2'
+  s.add_runtime_dependency 'multi_xml'
   s.add_runtime_dependency 'hashie', '~> 1.2'
+  s.add_runtime_dependency 'virtus'
 
   s.add_development_dependency 'rake'
   s.add_development_dependency 'maruku'

data/lib/grape.rb

@@ -9,6 +9,12 @@ module Grape
   autoload :Route,           'grape/route'
   autoload :Entity,          'grape/entity'
   autoload :Cookies,         'grape/cookies'
+  autoload :Validations,     'grape/validations'
+
+  module Exceptions
+    autoload :Base, 'grape/exceptions/base'
+  end
+  autoload :ValidationError, 'grape/exceptions/validation_error'
 
   module Middleware
     autoload :Base,      'grape/middleware/base'

data/lib/grape/api.rb

@@ -2,12 +2,15 @@ require 'rack/mount'
 require 'rack/auth/basic'
 require 'rack/auth/digest/md5'
 require 'logger'
+require 'grape/util/deep_merge'
 
 module Grape
   # The API class is the primary entry point for
   # creating Grape APIs.Users should subclass this
   # class in order to build an API.
   class API
+    extend Validations::ClassMethods
+
     class << self
       attr_reader :route_set
       attr_reader :versions
@@ -32,6 +35,7 @@ module Grape
         @endpoints = []
         @mountings = []
         @routes = nil
+        reset_validations!
       end
 
       def compile
@@ -96,12 +100,17 @@ module Grape
           options = args.pop if args.last.is_a? Hash
           options ||= {}
           options = {:using => :path}.merge!(options)
+
+          raise ArgumentError, "Must specify :vendor option." if options[:using] == :header && !options.has_key?(:vendor)
+
           @versions = versions | args
           nest(block) do
             set(:version, args)
             set(:version_options, options)
           end
         end
+
+        @versions.last unless @versions.nil?
       end
 
       # Add a description to the next namespace or function.
@@ -120,7 +129,7 @@ module Grape
       def format(new_format = nil)
         new_format ? set(:format, new_format.to_sym) : settings[:format]
       end
-      
+
       # Specify the format for error messages.
       # May be `:json` or `:txt` (default).
       def error_format(new_format = nil)
@@ -284,16 +293,22 @@ module Grape
         endpoint_options = {
           :method => methods,
           :path => paths,
-          :route_options => (route_options || {}).merge(@last_description || {})
+          :route_options => (@namespace_description || {}).deep_merge(@last_description || {}).deep_merge(route_options || {})
         }
         endpoints << Grape::Endpoint.new(settings.clone, endpoint_options, &block)
+
         @last_description = nil
+        reset_validations!
       end
 
       def before(&block)
         imbue(:befores, [block])
       end
 
+      def after_validation(&block)
+        imbue(:after_validations, [block])
+      end
+
       def after(&block)
         imbue(:afters, [block])
       end
@@ -308,9 +323,13 @@ module Grape
 
       def namespace(space = nil, &block)
         if space || block_given?
+          previous_namespace_description = @namespace_description
+          @namespace_description = (@namespace_description || {}).deep_merge(@last_description || {})
+          @last_description = nil
           nest(block) do
             set(:namespace, space.to_s) if space
           end
+          @namespace_description = previous_namespace_description
         else
           Rack::Mount::Utils.normalize_path(settings.stack.map{|s| s[:namespace]}.join('/'))
         end
@@ -376,6 +395,7 @@ module Grape
           instance_eval &block if block_given?
           blocks.each{|b| instance_eval &b}
           settings.pop   # when finished, we pop the context
+          reset_validations!
         else
           instance_eval &block
         end
@@ -397,6 +417,7 @@ module Grape
       self.class.endpoints.each do |endpoint|
         endpoint.mount_in(@route_set)
       end
+      add_head_not_allowed_methods
       @route_set.freeze
     end
 
@@ -405,5 +426,41 @@ module Grape
     end
 
     reset!
+
+    private
+
+    # For every resource add a 'OPTIONS' route that returns an HTTP 204 response
+    # with a list of HTTP methods that can be called. Also add a route that
+    # will return an HTTP 405 response for any HTTP method that the resource
+    # cannot handle.
+    def add_head_not_allowed_methods
+      allowed_methods = Hash.new{|h,k| h[k] = [] }
+      resources       = self.class.endpoints.map do |endpoint|
+        endpoint.options[:app] && endpoint.options[:app].respond_to?(:endpoints) ?
+          endpoint.options[:app].endpoints.map(&:routes) :
+          endpoint.routes
+      end
+      resources.flatten.each do |route|
+        allowed_methods[route.route_compiled] << route.route_method
+      end
+
+      allowed_methods.each do |path_info, methods|
+        allow_header = (["OPTIONS"] | methods).join(", ")
+        unless methods.include?("OPTIONS")
+          @route_set.add_route( proc { [204, { 'Allow' => allow_header }, []]}, {
+            :path_info      => path_info,
+            :request_method => "OPTIONS"
+          })
+        end
+        not_allowed_methods = %w(GET PUT POST DELETE PATCH HEAD) - methods
+        not_allowed_methods.each do |bad_method|
+          @route_set.add_route( proc { [405, { 'Allow' => allow_header }, []]}, {
+            :path_info      => path_info,
+            :request_method => bad_method
+          })
+        end
+      end
+    end
+
   end
 end

data/lib/grape/endpoint.rb

@@ -123,9 +123,31 @@ module Grape
         deep_merge(self.body_params)
     end
 
+    # A filtering method that will return a hash
+    # consisting only of keys that have been declared by a
+    # `params` statement.
+    #
+    # @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 = {})
+      options[:include_missing] = true unless options.key?(:include_missing)
+
+      unless settings[: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]
+        end
+        h
+      }
+    end
+
     # 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)
+      if ['POST', 'PUT'].include?(request.request_method.to_s.upcase) && request.content_length.to_i > 0
         return case env['CONTENT_TYPE']
           when 'application/json'
             MultiJson.decode(request.body.read)
@@ -159,7 +181,7 @@ module Grape
     def redirect(url, options = {})
       merged_options = {:permanent => false }.merge(options)
       if merged_options[:permanent]
-        status 304
+        status 301
       else
         if env['HTTP_VERSION'] == 'HTTP/1.1' && request.request_method.to_s.upcase != "GET"
           status 303
@@ -197,12 +219,12 @@ module Grape
         @header
       end
     end
-    
+
     # Set response content-type
     def content_type(val)
       header('Content-Type', val)
     end
-    
+
     # Set or get a cookie
     #
     # @example
@@ -255,6 +277,8 @@ module Grape
         entity_class ||= (settings[:representations] || {})[potential]
       end
 
+      entity_class ||= object.class.const_get(:Entity) if object.class.const_defined?(:Entity)
+
       root = options.delete(:root)
 
       representation = if entity_class
@@ -268,7 +292,7 @@ module Grape
       representation = { root => representation } if root
       body representation
     end
-    
+
     # Returns route information for the current request.
     #
     # @example
@@ -290,11 +314,20 @@ module Grape
 
       self.extend helpers
       cookies.read(@request)
+
       run_filters befores
+
+      # Retieve validations from this namespace and all parent namespaces.
+      settings.gather(:validations).each do |validator|
+        validator.validate!(params)
+      end
+
+      run_filters after_validations
+
       response_text = instance_eval &self.block
       run_filters afters
       cookies.write(header)
-      
+
       [status, header, [body || response_text]]
     end
 
@@ -305,10 +338,10 @@ module Grape
       b.use Grape::Middleware::Error,
         :default_status => settings[:default_error_status] || 403,
         :rescue_all => settings[:rescue_all],
-        :rescued_errors => settings[:rescued_errors],
+        :rescued_errors => aggregate_setting(:rescued_errors),
         :format => settings[:error_format] || :txt,
         :rescue_options => settings[:rescue_options],
-        :rescue_handlers => settings[:rescue_handlers] || {}
+        :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
@@ -320,7 +353,7 @@ module Grape
           :version_options => settings[:version_options]
         }
       end
-      
+
       b.use Grape::Middleware::Formatter,
         :format => settings[:format],
         :default_format => settings[:default_format] || :txt,
@@ -351,6 +384,12 @@ module Grape
       end
     end
 
+    def merged_setting(key)
+      settings.stack.inject({}) do |merged, frame|
+        merged.merge(frame[key] || {})
+      end
+    end
+
     def run_filters(filters)
       (filters || []).each do |filter|
         instance_eval &filter
@@ -358,6 +397,7 @@ module Grape
     end
 
     def befores; aggregate_setting(:befores) end
+    def after_validations; aggregate_setting(:after_validations) end
     def afters; aggregate_setting(:afters) end
   end
 end

data/lib/grape/entity.rb

@@ -43,6 +43,60 @@ module Grape
   class Entity
     attr_reader :object, :options
 
+    # The Entity DSL allows you to mix entity functionality into
+    # your existing classes.
+    module DSL
+      def self.included(base)
+        base.extend ClassMethods
+        ancestor_entity_class = base.ancestors.detect{|a| a.entity_class if a.respond_to?(:entity_class)}
+        base.const_set(:Entity, Class.new(ancestor_entity_class || Grape::Entity)) unless const_defined?(:Entity)
+      end
+
+      module ClassMethods
+        # Returns the automatically-created entity class for this
+        # Class.
+        def entity_class(search_ancestors=true)
+          klass = const_get(:Entity) if const_defined?(:Entity)
+          klass ||= ancestors.detect{|a| a.entity_class(false) if a.respond_to?(:entity_class) } if search_ancestors
+          klass
+        end
+
+        # Call this to make exposures to the entity for this Class.
+        # Can be called with symbols for the attributes to expose,
+        # a block that yields the full Entity DSL (See Grape::Entity),
+        # or both.
+        #
+        # @example Symbols only.
+        #
+        #   class User
+        #     include Grape::Entity::DSL
+        #     
+        #     entity :name, :email
+        #   end
+        #
+        # @example Mixed.
+        #
+        #   class User
+        #     include Grape::Entity::DSL
+        #     
+        #     entity :name, :email do
+        #       expose :latest_status, using: Status::Entity, if: :include_status
+        #       expose :new_attribute, :if => {:version => 'v2'}
+        #     end
+        #   end
+        def entity(*exposures, &block)
+          entity_class.expose *exposures if exposures.any?
+          entity_class.class_eval(&block) if block_given?
+          entity_class
+        end
+      end
+
+      # Instantiates an entity version of this object.
+      def entity
+        self.class.entity_class.new(self)
+      end
+    end
+
     # This method is the primary means by which you will declare what attributes
     # should be exposed by the entity.
     #
@@ -66,8 +120,8 @@ module Grape
     #   will be called with the represented object as well as the
     #   runtime options that were passed in. You can also just supply a
     #   block to the expose call to achieve the same effect.
-    # @option options :documentation Define documenation for an exposed 
-    #   field, typically the value is a hash with two fields, type and desc. 
+    # @option options :documentation Define documenation for an exposed
+    #   field, typically the value is a hash with two fields, type and desc.
     def self.expose(*args, &block)
       options = args.last.is_a?(Hash) ? args.pop : {}
 
@@ -98,13 +152,13 @@ module Grape
       @exposures
     end
 
-    # Returns a hash, the keys are symbolized references to fields in the entity, 
-    # the values are document keys in the entity's documentation key. When calling 
+    # Returns a hash, the keys are symbolized references to fields in the entity,
+    # the values are document keys in the entity's documentation key. When calling
     # #docmentation, any exposure without a documentation key will be ignored.
     def self.documentation
       @documentation ||= exposures.inject({}) do |memo, value|
                            unless value[1][:documentation].nil? || value[1][:documentation].empty?
-                             memo[value[0]] = value[1][:documentation] 
+                             memo[value[0]] = value[1][:documentation]
                            end
                            memo
                          end
@@ -118,7 +172,7 @@ module Grape
 
     # This allows you to declare a Proc in which exposures can be formatted with.
     # It take a block with an arity of 1 which is passed as the value of the exposed attribute.
-    # 
+    #
     # @param name [Symbol] the name of the formatter
     # @param block [Proc] the block that will interpret the exposed attribute
     #
@@ -259,7 +313,17 @@ module Grape
       return nil if object.nil?
       opts = options.merge(runtime_options || {})
       exposures.inject({}) do |output, (attribute, exposure_options)|
-        output[key_for(attribute)] = value_for(attribute, opts) if conditions_met?(exposure_options, opts)
+        if (exposure_options.has_key?(:proc) || object.respond_to?(attribute)) && conditions_met?(exposure_options, opts)
+          partial_output = value_for(attribute, opts)
+          output[key_for(attribute)] =
+            if partial_output.respond_to? :serializable_hash
+              partial_output.serializable_hash(runtime_options)
+            elsif partial_output.kind_of?(Array) && !partial_output.map {|o| o.respond_to? :serializable_hash}.include?(false)
+              partial_output.map {|o| o.serializable_hash}
+            else
+              partial_output
+            end
+        end
         output
       end
     end
@@ -278,7 +342,10 @@ module Grape
       if exposure_options[:proc]
         exposure_options[:proc].call(object, options)
       elsif exposure_options[:using]
-        exposure_options[:using].represent(object.send(attribute), :root => nil)
+        using_options = options.dup
+        using_options.delete(:collection)
+        using_options[:root] = nil
+        exposure_options[:using].represent(object.send(attribute), using_options)
       elsif exposure_options[:format_with]
         format_with = exposure_options[:format_with]
 

data/lib/grape/exceptions/base.rb

@@ -0,0 +1,17 @@
+module Grape
+  module Exceptions
+    class Base < StandardError
+      attr_reader :status, :message, :headers
+
+      def initialize(args = {})
+        @status = args[:status] || nil
+        @message = args[:message] || nil
+        @headers = args[:headers] || nil
+      end
+
+      def [](index)
+        self.send(index)
+      end 
+    end
+  end
+end