grape 0.3.0 → 0.7.0

data/lib/grape/exceptions/base.rb

@@ -1,9 +1,9 @@
 module Grape
   module Exceptions
     class Base < StandardError
-
       BASE_MESSAGES_KEY = 'grape.errors.messages'
       BASE_ATTRIBUTES_KEY = 'grape.errors.attributes'
+      FALLBACK_LOCALE = :en
 
       attr_reader :status, :message, :headers
 
@@ -14,20 +14,21 @@ module Grape
       end
 
       def [](index)
-        self.send(index)
+        send index
       end
 
       protected
+
       # TODO: translate attribute first
       # if BASE_ATTRIBUTES_KEY.key respond to a string message, then short_message is returned
       # if BASE_ATTRIBUTES_KEY.key respond to a Hash, means it may have problem , summary and resolution
-      def compose_message(key, attributes = {} )
+      def compose_message(key, attributes = {})
         short_message = translate_message(key, attributes)
         if short_message.is_a? Hash
           @problem = problem(key, attributes)
           @summary = summary(key, attributes)
           @resolution = resolution(key, attributes)
-          [ ["Problem", @problem], ["Summary", @summary], ["Resolution", @resolution]].reduce("") do |message, detail_array|
+          [["Problem", @problem], ["Summary", @summary], ["Resolution", @resolution]].reduce("") do |message, detail_array|
             message <<  "\n#{detail_array[0]}:\n  #{detail_array[1]}" unless detail_array[1].blank?
             message
           end
@@ -48,19 +49,18 @@ module Grape
         translate_message("#{key}.resolution", attributes)
       end
 
-
       def translate_attribute(key, options = {})
-        translate("#{BASE_ATTRIBUTES_KEY}.#{key}", { :default => key }.merge(options))
+        translate("#{BASE_ATTRIBUTES_KEY}.#{key}", { default: key }.merge(options))
       end
 
       def translate_message(key, options = {})
-        translate("#{BASE_MESSAGES_KEY}.#{key}", {:default => '' }.merge(options))
+        translate("#{BASE_MESSAGES_KEY}.#{key}", { default: '' }.merge(options))
       end
 
       def translate(key, options = {})
-        ::I18n.translate(key, options)
+        message = ::I18n.translate(key, options)
+        message.present? ? message : ::I18n.translate(key, options.merge(locale: FALLBACK_LOCALE))
       end
-
     end
   end
 end

data/lib/grape/exceptions/incompatible_option_values.rb

@@ -0,0 +1,10 @@
+# encoding: utf-8
+module Grape
+  module Exceptions
+    class IncompatibleOptionValues < Base
+      def initialize(option1, value1, option2, value2)
+        super(message: compose_message("incompatible_option_values", option1: option1, value1: value1, option2: option2, value2: value2))
+      end
+    end
+  end
+end

data/lib/grape/exceptions/invalid_formatter.rb

@@ -2,12 +2,9 @@
 module Grape
   module Exceptions
     class InvalidFormatter < Base
-
       def initialize(klass, to_format)
-        super(:message => compose_message("invalid_formatter", :klass => klass, :to_format => to_format))
+        super(message: compose_message("invalid_formatter", klass: klass, to_format: to_format))
       end
-
     end
-
   end
 end

data/lib/grape/exceptions/invalid_versioner_option.rb

@@ -1,14 +1,10 @@
 # encoding: utf-8
 module Grape
   module Exceptions
-
     class InvalidVersionerOption < Base
-
       def initialize(strategy)
-        super(:message => compose_message("invalid_versioner_option", :strategy => strategy))
+        super(message: compose_message("invalid_versioner_option", strategy: strategy))
       end
-
     end
-
   end
 end

data/lib/grape/exceptions/invalid_with_option_for_represent.rb

@@ -2,14 +2,9 @@
 module Grape
   module Exceptions
     class InvalidWithOptionForRepresent < Base
-
       def initialize
-        super(:message => compose_message("invalid_with_option_for_represent"))
+        super(message: compose_message("invalid_with_option_for_represent"))
       end
-
     end
-
   end
-
 end
-

data/lib/grape/exceptions/missing_mime_type.rb

@@ -2,13 +2,9 @@
 module Grape
   module Exceptions
     class MissingMimeType < Base
-
       def initialize(new_format)
-        super(:message => compose_message("missing_mime_type", :new_format => new_format))
+        super(message: compose_message("missing_mime_type", new_format: new_format))
       end
-
     end
-
   end
-
 end

data/lib/grape/exceptions/missing_option.rb

@@ -2,12 +2,9 @@
 module Grape
   module Exceptions
     class MissingOption < Base
-
       def initialize(option)
-        super(:message => compose_message("missing_option", :option => option))
+        super(message: compose_message("missing_option", option: option))
       end
-
     end
-
   end
 end

data/lib/grape/exceptions/missing_vendor_option.rb

@@ -2,12 +2,9 @@
 module Grape
   module Exceptions
     class MissingVendorOption < Base
-
       def initialize
-        super(:message => compose_message("missing_vendor_option"))
+        super(message: compose_message("missing_vendor_option"))
       end
-
     end
-
   end
 end

data/lib/grape/exceptions/unknown_options.rb

@@ -2,13 +2,9 @@
 module Grape
   module Exceptions
     class UnknownOptions < Base
-
       def initialize(options)
-        super(:message => compose_message("unknown_options", :options => options))
+        super(message: compose_message("unknown_options", options: options))
       end
-
     end
-
   end
-
 end

data/lib/grape/exceptions/unknown_validator.rb

@@ -2,11 +2,9 @@
 module Grape
   module Exceptions
     class UnknownValidator < Base
-
       def initialize(validator_type)
-        super(:message => compose_message("unknown_validator", :validator_type => validator_type))
+        super(message: compose_message("unknown_validator", validator_type: validator_type))
       end
-
     end
   end
 end

data/lib/grape/exceptions/validation.rb

@@ -6,11 +6,21 @@ module Grape
       attr_accessor :param
 
       def initialize(args = {})
-        @param = args[:param].to_s if args.has_key? :param
-        attribute = translate_attribute(@param)
-        args[:message] = translate_message(args[:message_key], :attribute => attribute)
+        raise "Param is missing:" unless args.has_key? :param
+        @param = args[:param]
+        args[:message] = translate_message(args[:message_key]) if args.has_key? :message_key
         super
       end
+
+      # remove all the unnecessary stuff from Grape::Exceptions::Base like status
+      # and headers when converting a validation error to json or string
+      def as_json(*args)
+        to_s
+      end
+
+      def to_s
+        message
+      end
     end
   end
 end

data/lib/grape/exceptions/validation_errors.rb

@@ -0,0 +1,43 @@
+require 'grape/exceptions/base'
+
+module Grape
+  module Exceptions
+    class ValidationErrors < Grape::Exceptions::Base
+      include Enumerable
+
+      attr_reader :errors
+
+      def initialize(args = {})
+        @errors = {}
+        args[:errors].each do |validation_error|
+          @errors[validation_error.param] ||= []
+          @errors[validation_error.param] << validation_error
+        end
+        super message: full_messages.join(', '), status: 400
+      end
+
+      def each
+        errors.each_pair do |attribute, errors|
+          errors.each do |error|
+            yield attribute, error
+          end
+        end
+      end
+
+      private
+
+      def full_messages
+        map { |attribute, error| full_message(attribute, error) }.uniq
+      end
+
+      def full_message(attribute, error)
+        I18n.t(
+          "grape.errors.format".to_sym,
+          default: "%{attribute} %{message}",
+          attribute: translate_attribute(attribute),
+          message: error.message
+        )
+      end
+    end
+  end
+end

data/lib/grape/formatter/base.rb

@@ -1,14 +1,13 @@
 module Grape
   module Formatter
     module Base
-
       class << self
-
         FORMATTERS = {
-          :json => Grape::Formatter::Json,
-          :serializable_hash => Grape::Formatter::SerializableHash,
-          :txt => Grape::Formatter::Txt,
-          :xml => Grape::Formatter::Xml
+          json: Grape::Formatter::Json,
+          jsonapi: Grape::Formatter::Json,
+          serializable_hash: Grape::Formatter::SerializableHash,
+          txt: Grape::Formatter::Txt,
+          xml: Grape::Formatter::Xml
         }
 
         def formatters(options)
@@ -26,7 +25,6 @@ module Grape
             spec
           end
         end
-
       end
     end
   end

data/lib/grape/formatter/json.rb

@@ -2,13 +2,10 @@ module Grape
   module Formatter
     module Json
       class << self
-
         def call(object, env)
-          return object if object.is_a?(String)
           return object.to_json if object.respond_to?(:to_json)
           MultiJson.dump(object)
         end
-
       end
     end
   end

data/lib/grape/formatter/serializable_hash.rb

@@ -2,7 +2,6 @@ module Grape
   module Formatter
     module SerializableHash
       class << self
-
         def call(object, env)
           return object if object.is_a?(String)
           return MultiJson.dump(serialize(object)) if serializable?(object)
@@ -12,23 +11,24 @@ module Grape
 
         private
 
-          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 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
-              object.serializable_hash
-            elsif object.kind_of?(Array) && !object.map {|o| o.respond_to? :serializable_hash }.include?(false)
-              object.map {|o| o.serializable_hash }
-            elsif object.kind_of?(Hash)
-              object.inject({}) { |h,(k,v)| h[k] = serialize(v); h }
-            else
-              object
+        def serialize(object)
+          if object.respond_to? :serializable_hash
+            object.serializable_hash
+          elsif object.kind_of?(Array) && !object.map { |o| o.respond_to? :serializable_hash }.include?(false)
+            object.map { |o| o.serializable_hash }
+          elsif object.kind_of?(Hash)
+            object.inject({}) do |h, (k, v)|
+              h[k] = serialize(v)
+              h
             end
+          else
+            object
           end
+        end
       end
     end
   end

data/lib/grape/formatter/txt.rb

@@ -2,11 +2,9 @@ module Grape
   module Formatter
     module Txt
       class << self
-
         def call(object, env)
           object.respond_to?(:to_txt) ? object.to_txt : object.to_s
         end
-
       end
     end
   end

data/lib/grape/formatter/xml.rb

@@ -2,12 +2,10 @@ module Grape
   module Formatter
     module Xml
       class << self
-
         def call(object, env)
           return object.to_xml if object.respond_to?(:to_xml)
           raise Grape::Exceptions::InvalidFormatter.new(object.class, 'xml')
         end
-
       end
     end
   end

data/lib/grape/http/request.rb

@@ -0,0 +1,26 @@
+module Grape
+  class Request < Rack::Request
+    def params
+      @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
+      @headers ||= env.dup.inject({}) do |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
+end

data/lib/grape/locale/en.yml

@@ -1,18 +1,20 @@
 en:
   grape:
     errors:
+      format: ! '%{attribute} %{message}'
       messages:
-        coerce: 'invalid parameter: %{attribute}'
-        presence: 'missing parameter: %{attribute}'
-        regexp: 'invalid parameter: %{attribute}'
+        coerce: 'is invalid'
+        presence: 'is missing'
+        regexp: 'is invalid'
+        values: 'does not have a valid value'
         missing_vendor_option:
           problem: 'missing :vendor option.'
-          summary: 'when version using header, you must specify :verdor option. '
+          summary: 'when version using header, you must specify :vendor option. '
           resolution: "eg: version 'v1', :using => :header, :vendor => 'twitter'"
         missing_mime_type:
           problem: 'missing mime type for %{new_format}'
           resolution:
-            "you can choose exist mime type from Grape::ContentTypes::CONTENT_TYPES
+            "you can choose existing mime type from Grape::ContentTypes::CONTENT_TYPES
             or add your own with content_type :%{new_format}, 'application/%{new_format}'
             "
         invalid_with_option_for_represent:
@@ -25,3 +27,4 @@ en:
           resolution: 'available strategy for :using is :path, :header, :param'
         unknown_validator: 'unknown validator: %{validator_type}'
         unknown_options: 'unknown options: %{options}'
+        incompatible_option_values: '%{option1}: %{value1} is incompatible with %{option2}: %{value2}'

data/lib/grape/middleware/auth/base.rb

@@ -0,0 +1,30 @@
+require 'rack/auth/basic'
+
+module Grape
+  module Middleware
+    module Auth
+      class Base < Grape::Middleware::Base
+        attr_reader :authenticator
+
+        def initialize(app, options = {}, &authenticator)
+          super(app, options)
+          @authenticator = authenticator
+        end
+
+        def base_request
+          raise NotImplementedError, "You must implement base_request."
+        end
+
+        def credentials
+          base_request.provided? ? base_request.credentials : [nil, nil]
+        end
+
+        def before
+          unless authenticator.call(*credentials)
+            throw :error, status: 401, message: "API Authorization Failed."
+          end
+        end
+      end
+    end
+  end
+end

data/lib/grape/middleware/auth/basic.rb

@@ -3,28 +3,11 @@ require 'rack/auth/basic'
 module Grape
   module Middleware
     module Auth
-      class Basic < Grape::Middleware::Base
-        attr_reader :authenticator
-        
-        def initialize(app, options = {}, &authenticator)
-          super(app, options)
-          @authenticator = authenticator
-        end
-        
-        def basic_request
+      class Basic < Grape::Middleware::Auth::Base
+        def base_request
           Rack::Auth::Basic::Request.new(env)
         end
-        
-        def credentials
-          basic_request.provided?? basic_request.credentials : [nil, nil]
-        end
-        
-        def before
-          unless authenticator.call(*credentials)
-            throw :error, :status => 401, :message => "API Authorization Failed."
-          end
-        end
       end
     end
   end
-end
+end

data/lib/grape/middleware/auth/digest.rb

@@ -3,27 +3,10 @@ require 'rack/auth/digest/md5'
 module Grape
   module Middleware
     module Auth
-      class Digest < Grape::Middleware::Base
-        attr_reader :authenticator
-        
-        def initialize(app, options = {}, &authenticator)
-          super(app, options)
-          @authenticator = authenticator
-        end
-        
-        def digest_request
+      class Digest < Grape::Middleware::Auth::Base
+        def base_request
           Rack::Auth::Digest::Request.new(env)
         end
-        
-        def credentials
-          digest_request.provided?? digest_request.credentials : [nil, nil]
-        end
-        
-        def before
-          unless authenticator.call(*credentials)
-            throw :error, :status => 401, :message => "API Authorization Failed."
-          end
-        end
       end
     end
   end

data/lib/grape/middleware/auth/oauth2.rb

@@ -3,21 +3,30 @@ module Grape::Middleware::Auth
   class OAuth2 < Grape::Middleware::Base
     def default_options
       {
-        :token_class => 'AccessToken',
-        :realm => 'OAuth API',
-        :parameter => %w(bearer_token oauth_token),
-        :accepted_headers => %w(HTTP_AUTHORIZATION X_HTTP_AUTHORIZATION X-HTTP_AUTHORIZATION REDIRECT_X_HTTP_AUTHORIZATION),
-        :header => [/Bearer (.*)/i, /OAuth (.*)/i]
+        token_class: 'AccessToken',
+        realm: 'OAuth API',
+        parameter: %w(bearer_token oauth_token access_token),
+        accepted_headers: %w(HTTP_AUTHORIZATION X_HTTP_AUTHORIZATION X-HTTP_AUTHORIZATION REDIRECT_X_HTTP_AUTHORIZATION),
+        header: [/Bearer (.*)/i, /OAuth (.*)/i],
+        required: true
       }
     end
-    
+
     def before
       verify_token(token_parameter || token_header)
     end
 
+    def request
+      @request ||= Grape::Request.new(env)
+    end
+
+    def params
+      @params ||= request.params
+    end
+
     def token_parameter
       Array(options[:parameter]).each do |p|
-        return request[p] if request[p]
+        return params[p] if params[p]
       end
       nil
     end
@@ -25,9 +34,7 @@ module Grape::Middleware::Auth
     def token_header
       return false unless authorization_header
       Array(options[:header]).each do |regexp|
-        if authorization_header =~ regexp
-          return $1
-        end
+        return $1 if authorization_header =~ regexp
       end
       nil
     end
@@ -38,15 +45,16 @@ module Grape::Middleware::Auth
       end
       nil
     end
-    
+
     def token_class
-      @klass ||= eval(options[:token_class])
+      @klass ||= eval(options[:token_class]) # rubocop:disable Eval
     end
-    
+
     def verify_token(token)
-      if token = token_class.verify(token)
+      token = token_class.verify(token)
+      if token
         if token.respond_to?(:expired?) && token.expired?
-          error_out(401, 'expired_token')
+          error_out(401, 'invalid_grant')
         else
           if !token.respond_to?(:permission_for?) || token.permission_for?(env)
             env['api.token'] = token
@@ -54,19 +62,18 @@ module Grape::Middleware::Auth
             error_out(403, 'insufficient_scope')
           end
         end
-      else
-        error_out(401, 'invalid_token')
+      elsif !!options[:required]
+        error_out(401, 'invalid_grant')
       end
     end
-    
+
     def error_out(status, error)
       throw :error,
-        :message => error,
-        :status => status,
-        :headers => {
-          'WWW-Authenticate' => "OAuth realm='#{options[:realm]}', error='#{error}'"
-        }
+            message: error,
+            status: status,
+            headers: {
+              'WWW-Authenticate' => "OAuth realm='#{options[:realm]}', error='#{error}'"
+            }
     end
   end
 end
-    

data/lib/grape/middleware/base.rb

@@ -27,14 +27,13 @@ module Grape
 
       # @abstract
       # Called before the application is called in the middleware lifecycle.
-      def before; end
+      def before
+      end
+
       # @abstract
       # Called after the application is called in the middleware lifecycle.
       # @return [Response, nil] a Rack SPEC response or nil to call the application afterwards.
-      def after; end
-
-      def request
-        Rack::Request.new(self.env)
+      def after
       end
 
       def response
@@ -54,9 +53,10 @@ module Grape
       end
 
       def mime_types
-        content_types.invert
+        content_types.each_with_object({}) { |(k, v), types_without_params|
+          types_without_params[k] = v.split(';').first
+        }.invert
       end
-
     end
   end
 end