grape 0.8.0 → 0.9.0

data/lib/grape/error_formatter/base.rb

@@ -26,6 +26,34 @@ module Grape
           end
         end
       end
+
+      module_function
+
+      def present(message, env)
+        present_options = {}
+        present_options[:with] = message.delete(:with) if message.is_a?(Hash)
+
+        presenter = env['api.endpoint'].entity_class_for_obj(message, present_options)
+
+        unless presenter || env['rack.routing_args'].nil?
+          # env['api.endpoint'].route does not work when the error occurs within a middleware
+          # the Endpoint does not have a valid env at this moment
+          http_codes = env['rack.routing_args'][:route_info].route_http_codes || []
+          found_code = http_codes.find do |http_code|
+            (http_code[0].to_i == env['api.endpoint'].status) && http_code[2].respond_to?(:represent)
+          end
+
+          presenter = found_code[2] if found_code
+        end
+
+        if presenter
+          embeds = { env: env }
+          embeds[:version] = env['api.version'] if env['api.version']
+          message = presenter.represent(message, embeds).serializable_hash
+        end
+
+        message
+      end
     end
   end
 end

data/lib/grape/error_formatter/json.rb

@@ -3,6 +3,8 @@ module Grape
     module Json
       class << self
         def call(message, backtrace, options = {}, env = nil)
+          message = Grape::ErrorFormatter::Base.present(message, env)
+
           result = message.is_a?(Hash) ? message : { error: message }
           if (options[:rescue_options] || {})[:backtrace] && backtrace && !backtrace.empty?
             result = result.merge(backtrace: backtrace)

data/lib/grape/error_formatter/txt.rb

@@ -3,6 +3,8 @@ module Grape
     module Txt
       class << self
         def call(message, backtrace, options = {}, env = nil)
+          message = Grape::ErrorFormatter::Base.present(message, env)
+
           result = message.is_a?(Hash) ? MultiJson.dump(message) : message
           if (options[:rescue_options] || {})[:backtrace] && backtrace && !backtrace.empty?
             result += "\r\n "

data/lib/grape/error_formatter/xml.rb

@@ -3,6 +3,8 @@ module Grape
     module Xml
       class << self
         def call(message, backtrace, options = {}, env = nil)
+          message = Grape::ErrorFormatter::Base.present(message, env)
+
           result = message.is_a?(Hash) ? message : { message: message }
           if (options[:rescue_options] || {})[:backtrace] && backtrace && !backtrace.empty?
             result = result.merge(backtrace: backtrace)

data/lib/grape/exceptions/base.rb

@@ -49,6 +49,12 @@ module Grape
         translate_message("#{key}.resolution", attributes)
       end
 
+      def translate_attributes(keys, options = {})
+        keys.map do |key|
+          translate("#{BASE_ATTRIBUTES_KEY}.#{key}", { default: key }.merge(options))
+        end.join(", ")
+      end
+
       def translate_attribute(key, options = {})
         translate("#{BASE_ATTRIBUTES_KEY}.#{key}", { default: key }.merge(options))
       end

data/lib/grape/exceptions/validation.rb

@@ -3,11 +3,11 @@ require 'grape/exceptions/base'
 module Grape
   module Exceptions
     class Validation < Grape::Exceptions::Base
-      attr_accessor :param
+      attr_accessor :params
 
       def initialize(args = {})
-        raise "Param is missing:" unless args.key? :param
-        @param = args[:param]
+        raise "Params are missing:" unless args.key? :params
+        @params = args[:params]
         args[:message] = translate_message(args[:message_key]) if args.key? :message_key
         super
       end

data/lib/grape/exceptions/validation_errors.rb

@@ -10,8 +10,8 @@ module Grape
       def initialize(args = {})
         @errors = {}
         args[:errors].each do |validation_error|
-          @errors[validation_error.param] ||= []
-          @errors[validation_error.param] << validation_error
+          @errors[validation_error.params] ||= []
+          @errors[validation_error.params] << validation_error
         end
         super message: full_messages.join(', '), status: 400
       end
@@ -24,17 +24,30 @@ module Grape
         end
       end
 
+      def as_json
+        errors.map do |k, v|
+          {
+            params: k,
+            messages: v.map(&:to_s)
+          }
+        end
+      end
+
+      def to_json
+        as_json.to_json
+      end
+
       private
 
       def full_messages
-        map { |attribute, error| full_message(attribute, error) }.uniq
+        map { |attributes, error| full_message(attributes, error) }.uniq
       end
 
-      def full_message(attribute, error)
+      def full_message(attributes, error)
         I18n.t(
           "grape.errors.format".to_sym,
-          default: "%{attribute} %{message}",
-          attribute: translate_attribute(attribute),
+          default: "%{attributes} %{message}",
+          attributes: attributes.count == 1 ? translate_attribute(attributes.first) : translate_attributes(attributes),
           message: error.message
         )
       end

data/lib/grape/locale/en.yml

@@ -1,7 +1,7 @@
 en:
   grape:
     errors:
-      format: ! '%{attribute} %{message}'
+      format: ! '%{attributes} %{message}'
       messages:
         coerce: 'is invalid'
         presence: 'is missing'
@@ -10,7 +10,7 @@ en:
         missing_vendor_option:
           problem: 'missing :vendor option.'
           summary: 'when version using header, you must specify :vendor option. '
-          resolution: "eg: version 'v1', :using => :header, :vendor => 'twitter'"
+          resolution: "eg: version 'v1', using: :header, vendor: 'twitter'"
         missing_mime_type:
           problem: 'missing mime type for %{new_format}'
           resolution:
@@ -29,4 +29,6 @@ en:
         unknown_options: 'unknown options: %{options}'
         incompatible_option_values: '%{option1}: %{value1} is incompatible with %{option2}: %{value2}'
         mutual_exclusion: 'are mutually exclusive'
-        exactly_one: "- exactly one parameter must be provided"
+        at_least_one: 'are missing, at least one parameter must be provided'
+        exactly_one: 'are missing, exactly one parameter must be provided'
+

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

@@ -3,25 +3,41 @@ require 'rack/auth/basic'
 module Grape
   module Middleware
     module Auth
-      class Base < Grape::Middleware::Base
-        attr_reader :authenticator
+      class Base
+        attr_accessor :options, :app, :env
 
-        def initialize(app, options = {}, &authenticator)
-          super(app, options)
-          @authenticator = authenticator
+        def initialize(app, options = {})
+          @app = app
+          @options = options || {}
         end
 
-        def base_request
-          raise NotImplementedError, "You must implement base_request."
+        def context
+          env['api.endpoint']
         end
 
-        def credentials
-          base_request.provided? ? base_request.credentials : [nil, nil]
+        def call(env)
+          dup._call(env)
         end
 
-        def before
-          unless authenticator.call(*credentials)
-            throw :error, status: 401, message: "API Authorization Failed."
+        def _call(env)
+          self.env = env
+
+          if options.key?(:type)
+            auth_proc         = options[:proc]
+            auth_proc_context = context
+
+            strategy_info   = Grape::Middleware::Auth::Strategies[options[:type]]
+
+            throw(:error, status: 401, message: 'API Authorization Failed.') unless strategy_info.present?
+
+            strategy = strategy_info.create(@app, options) do |*args|
+              auth_proc_context.instance_exec(*args, &auth_proc)
+            end
+
+            strategy.call(env)
+
+          else
+            app.call(env)
           end
         end
       end

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

@@ -0,0 +1,35 @@
+require 'rack/auth/basic'
+
+module Grape
+  module Middleware
+    module Auth
+      module DSL
+        # Add an authentication type to the API. Currently
+        # only `:http_basic`, `:http_digest` are supported.
+        def auth(type = nil, options = {}, &block)
+          if type
+            set(:auth, { type: type.to_sym, proc: block }.merge(options))
+            use Grape::Middleware::Auth::Base, settings[:auth]
+          else
+            settings[:auth]
+          end
+        end
+
+        # Add HTTP Basic authorization to the API.
+        #
+        # @param [Hash] options A hash of options.
+        # @option options [String] :realm "API Authorization" The HTTP Basic realm.
+        def http_basic(options = {}, &block)
+          options[:realm] ||= "API Authorization"
+          auth :http_basic, options, &block
+        end
+
+        def http_digest(options = {}, &block)
+          options[:realm] ||= "API Authorization"
+          options[:opaque] ||= "secret"
+          auth :http_digest, options, &block
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+module Grape
+  module Middleware
+    module Auth
+      module Strategies
+        module_function
+
+        def add(label, strategy, option_fetcher = ->(_) { [] })
+          auth_strategies[label] =  StrategyInfo.new(strategy, option_fetcher)
+        end
+
+        def auth_strategies
+          @auth_strategies ||= {
+            http_basic: StrategyInfo.new(Rack::Auth::Basic, ->(settings) {[settings[:realm]] }),
+            http_digest: StrategyInfo.new(Rack::Auth::Digest::MD5, ->(settings) { [settings[:realm], settings[:opaque]] })
+          }
+        end
+
+        def [](label)
+          auth_strategies[label]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+module Grape
+  module Middleware
+    module Auth
+      StrategyInfo = Struct.new(:auth_class, :settings_fetcher) do
+
+        def create(app, options, &block)
+          strategy_args = settings_fetcher.call(options)
+
+          auth_class.new(app, *strategy_args, &block)
+        end
+
+      end
+    end
+  end
+end

data/lib/grape/validations.rb

@@ -10,10 +10,6 @@ module Grape
         @attrs = Array(attrs)
         @required = required
         @scope = scope
-
-        if options.is_a?(Hash) && !options.empty?
-          raise Grape::Exceptions.UnknownOptions.new(options.keys)
-        end
       end
 
       def validate!(params)
@@ -84,6 +80,8 @@ module Grape
     class ParamsScope
       attr_accessor :element, :parent
 
+      include Grape::DSL::Parameters
+
       def initialize(opts, &block)
         @element  = opts[:element]
         @parent   = opts[:parent]
@@ -92,7 +90,7 @@ module Grape
         @type     = opts[:type]
         @declared_params = []
 
-        instance_eval(&block)
+        instance_eval(&block) if block_given?
 
         configure_declared_params
       end
@@ -103,72 +101,6 @@ module Grape
         parent.should_validate?(parameters)
       end
 
-      def requires(*attrs, &block)
-        orig_attrs = attrs.clone
-
-        opts = attrs.last.is_a?(Hash) ? attrs.pop : nil
-
-        if opts && opts[:using]
-          require_required_and_optional_fields(attrs.first, opts)
-        else
-          validate_attributes(attrs, opts, &block)
-
-          block_given? ? new_scope(orig_attrs, &block) :
-            push_declared_params(attrs)
-        end
-      end
-
-      def optional(*attrs, &block)
-        orig_attrs = attrs
-
-        validations = {}
-        validations.merge!(attrs.pop) if attrs.last.is_a?(Hash)
-        validations[:type] ||= Array if block_given?
-        validates(attrs, validations)
-
-        block_given? ? new_scope(orig_attrs, true, &block) :
-          push_declared_params(attrs)
-      end
-
-      def mutually_exclusive(*attrs)
-        validates(attrs, mutual_exclusion: true)
-      end
-
-      def exactly_one_of(*attrs)
-        validates(attrs, exactly_one_of: true)
-      end
-
-      def group(*attrs, &block)
-        requires(*attrs, &block)
-      end
-
-      def params(params)
-        params = @parent.params(params) if @parent
-        if @element
-          if params.is_a?(Array)
-            params = params.flat_map { |el| el[@element] || {} }
-          elsif params.is_a?(Hash)
-            params = params[@element] || {}
-          else
-            params = {}
-          end
-        end
-        params
-      end
-
-      def use(*names)
-        named_params = @api.settings[:named_params] || {}
-        options = names.last.is_a?(Hash) ? names.pop : {}
-        names.each do |name|
-          params_block = named_params.fetch(name) do
-            raise "Params :#{name} not found!"
-          end
-          instance_exec(options, &params_block)
-        end
-      end
-      alias_method :use_scope, :use
-      alias_method :includes, :use
-
       def full_name(name)
         return "#{@parent.full_name(@element)}[#{name}]" if @parent
         name.to_s
@@ -292,27 +224,6 @@ module Grape
         end
       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(api: self, type: Hash, &block)
-      end
-
-      def document_attribute(names, opts)
-        @last_description ||= {}
-        @last_description[:params] ||= {}
-        Array(names).each do |name|
-          @last_description[:params][name[:full_name].to_s] ||= {}
-          @last_description[:params][name[:full_name].to_s].merge!(opts)
-        end
-      end
-    end
   end
 end
 

data/lib/grape/validations/at_least_one_of.rb

@@ -0,0 +1,25 @@
+module Grape
+  module Validations
+    class AtLeastOneOfValidator < Validator
+      attr_reader :params
+
+      def validate!(params)
+        @params = params
+        if no_exclusive_params_are_present
+          raise Grape::Exceptions::Validation, params: attrs.map(&:to_s), message_key: :at_least_one
+        end
+        params
+      end
+
+      private
+
+      def no_exclusive_params_are_present
+        keys_in_common.length == 0
+      end
+
+      def keys_in_common
+        (attrs.map(&:to_s) & params.stringify_keys.keys).map(&:to_s)
+      end
+    end
+  end
+end