grape 0.1.1 → 2.4.0

data/lib/grape/json.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Grape
+  if defined?(::MultiJson)
+    Json = ::MultiJson
+  else
+    Json = ::JSON
+    Json::ParseError = Json::ParserError
+  end
+end

data/lib/grape/locale/en.yml

@@ -0,0 +1,59 @@
+---
+en:
+  grape:
+    errors:
+      format: '%{attributes} %{message}'
+      messages:
+        all_or_none: 'provide all or none of parameters'
+        at_least_one: 'are missing, at least one parameter must be provided'
+        blank: 'is empty'
+        coerce: 'is invalid'
+        conflicting_types: 'query params contains conflicting types'
+        empty_message_body: 'empty message body supplied with %{body_format} content-type'
+        exactly_one: 'are missing, exactly one parameter must be provided'
+        except_values: 'has a value not allowed'
+        incompatible_option_values: '%{option1}: %{value1} is incompatible with %{option2}: %{value2}'
+        invalid_accept_header:
+          problem: 'invalid accept header'
+          resolution: '%{message}'
+        invalid_formatter: 'cannot convert %{klass} to %{to_format}'
+        invalid_message_body:
+          problem: 'message body does not match declared format'
+          resolution: 'when specifying %{body_format} as content-type, you must pass valid %{body_format} in the request''s ''body'' '
+        invalid_parameters: 'query params contains invalid format or byte sequence'
+        invalid_response: 'Invalid response'
+        invalid_version_header:
+          problem: 'invalid version header'
+          resolution: '%{message}'
+        invalid_versioner_option:
+          problem: 'unknown :using for versioner: %{strategy}'
+          resolution: 'available strategy for :using is :path, :header, :accept_version_header, :param'
+        invalid_with_option_for_represent:
+          problem: 'you must specify an entity class in the :with option'
+          resolution: 'eg: represent User, :with => Entity::User'
+        length: 'is expected to have length within %{min} and %{max}'
+        length_is: 'is expected to have length exactly equal to %{is}'
+        length_max: 'is expected to have length less than or equal to %{max}'
+        length_min: 'is expected to have length greater than or equal to %{min}'
+        missing_group_type: 'group type is required'
+        missing_mime_type:
+          problem: 'missing mime type for %{new_format}'
+          resolution: 'you can choose existing mime type from Grape::ContentTypes::CONTENT_TYPES or add your own with content_type :%{new_format}, ''application/%{new_format}'' '
+        missing_option: 'you must specify :%{option} options'
+        missing_vendor_option:
+          problem: 'missing :vendor option'
+          resolution: 'eg: version ''v1'', using: :header, vendor: ''twitter'''
+          summary: 'when version using header, you must specify :vendor option'
+        mutual_exclusion: 'are mutually exclusive'
+        presence: 'is missing'
+        regexp: 'is invalid'
+        same_as: 'is not the same as %{parameter}'
+        too_deep_parameters: 'query params are recursively nested over the specified limit (%{limit})'
+        too_many_multipart_files: 'the number of uploaded files exceeded the system''s configured limit (%{limit})'
+        unknown_auth_strategy: 'unknown auth strategy: %{strategy}'
+        unknown_options: 'unknown options: %{options}'
+        unknown_parameter: 'unknown parameter: %{param}'
+        unknown_params_builder: 'unknown params_builder: %{params_builder_type}'
+        unknown_validator: 'unknown validator: %{validator_type}'
+        unsupported_group_type: 'group type must be Array, Hash, JSON or Array[JSON]'
+        values: 'does not have a valid value'

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Grape
+  module Middleware
+    module Auth
+      class Base < Grape::Middleware::Base
+        def initialize(app, **options)
+          super
+          @auth_strategy = Grape::Middleware::Auth::Strategies[options[:type]].tap do |auth_strategy|
+            raise Grape::Exceptions::UnknownAuthStrategy.new(strategy: options[:type]) unless auth_strategy
+          end
+        end
+
+        def call!(env)
+          @env = env
+          @auth_strategy.create(app, options) do |*args|
+            context.instance_exec(*args, &options[:proc])
+          end.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Grape
+  module Middleware
+    module Auth
+      module DSL
+        def auth(type = nil, options = {}, &block)
+          if type
+            namespace_inheritable(:auth, options.reverse_merge(type: type.to_sym, proc: block))
+            use Grape::Middleware::Auth::Base, namespace_inheritable(:auth)
+          else
+            namespace_inheritable(: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'
+
+          if options[:realm].respond_to?(:values_at)
+            options[:realm][:opaque] ||= 'secret'
+          else
+            options[:opaque] ||= 'secret'
+          end
+
+          auth :http_digest, options, &block
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+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]] })
+          }
+        end
+
+        def [](label)
+          auth_strategies[label]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+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/middleware/base.rb

@@ -1,43 +1,114 @@
+# frozen_string_literal: true
+
 module Grape
   module Middleware
     class Base
+      include Grape::DSL::Headers
+
       attr_reader :app, :env, :options
-      
+
       # @param [Rack Application] app The standard argument for a Rack middleware.
       # @param [Hash] options A hash of options, simply stored for use by subclasses.
-      def initialize(app, options = {})
+      def initialize(app, **options)
         @app = app
-        @options = default_options.merge(options)
+        @options = merge_default_options(options)
+        @app_response = nil
       end
-      
-      def default_options; {} end
-      
+
       def call(env)
-        dup.call!(env)
+        dup.call!(env).to_a
       end
-      
+
       def call!(env)
         @env = env
         before
-        @app_response = @app.call(@env)
-        after || @app_response
+        begin
+          @app_response = @app.call(@env)
+        ensure
+          begin
+            after_response = after
+          rescue StandardError => e
+            warn "caught error of type #{e.class} in after callback inside #{self.class.name} : #{e.message}"
+            raise e
+          end
+        end
+
+        response = after_response || @app_response
+        merge_headers response
+        response
       end
-      
+
       # @abstract
       # Called before the application is called in the middleware lifecycle.
       def before; end
+
       # @abstract
       # Called after the application is called in the middleware lifecycle.
-      # @returns [Response, nil] a Rack SPEC response or nil to call the application afterwards.
+      # @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 rack_request
+        @rack_request ||= Rack::Request.new(env)
       end
-      
+
+      def context
+        env[Grape::Env::API_ENDPOINT]
+      end
+
       def response
-        Rack::Response.new(@app_response)
+        return @app_response if @app_response.is_a?(Rack::Response)
+
+        @app_response = Rack::Response[*@app_response]
+      end
+
+      def content_types
+        @content_types ||= Grape::ContentTypes.content_types_for(options[:content_types])
+      end
+
+      def mime_types
+        @mime_types ||= Grape::ContentTypes.mime_types_for(content_types)
+      end
+
+      def content_type_for(format)
+        content_types_indifferent_access[format]
+      end
+
+      def content_type
+        content_type_for(env[Grape::Env::API_FORMAT] || options[:format]) || 'text/html'
+      end
+
+      def query_params
+        rack_request.GET
+      rescue Rack::QueryParser::ParamsTooDeepError
+        raise Grape::Exceptions::TooDeepParameters.new(Rack::Utils.param_depth_limit)
+      rescue Rack::Utils::ParameterTypeError
+        raise Grape::Exceptions::ConflictingTypes
+      end
+
+      private
+
+      def merge_headers(response)
+        return unless headers.is_a?(Hash)
+
+        case response
+        when Rack::Response then response.headers.merge!(headers)
+        when Array          then response[1].merge!(headers)
+        end
+      end
+
+      def content_types_indifferent_access
+        @content_types_indifferent_access ||= content_types.with_indifferent_access
+      end
+
+      def merge_default_options(options)
+        if respond_to?(:default_options)
+          default_options.deep_merge(options)
+        elsif self.class.const_defined?(:DEFAULT_OPTIONS)
+          self.class::DEFAULT_OPTIONS.deep_merge(options)
+        else
+          options
+        end
       end
     end
   end
-end
+end

data/lib/grape/middleware/error.rb

@@ -1,21 +1,140 @@
-require 'grape/middleware/base'
+# frozen_string_literal: true
 
 module Grape
   module Middleware
     class Error < Base
+      DEFAULT_OPTIONS = {
+        default_status: 500,
+        default_message: '',
+        format: :txt,
+        rescue_all: false,
+        rescue_grape_exceptions: false,
+        rescue_subclasses: true,
+        rescue_options: {
+          backtrace: false,
+          original_exception: false
+        }.freeze
+      }.freeze
+
+      def initialize(app, **options)
+        super
+        self.class.include(options[:helpers]) if options[:helpers]
+      end
+
       def call!(env)
         @env = env
-        result = catch :error do
-          @app.call(@env)
-        end
-        
-        result ||= {}
-        result.is_a?(Hash) ? error_response(result) : result
+        error_response(catch(:error) { return @app.call(@env) })
+      rescue Exception => e # rubocop:disable Lint/RescueException
+        run_rescue_handler(find_handler(e.class), e, @env[Grape::Env::API_ENDPOINT])
+      end
+
+      private
+
+      def rack_response(status, headers, message)
+        message = Rack::Utils.escape_html(message) if headers[Rack::CONTENT_TYPE] == 'text/html'
+        Rack::Response.new(Array.wrap(message), Rack::Utils.status_code(status), Grape::Util::Header.new.merge(headers))
+      end
+
+      def format_message(message, backtrace, original_exception = nil)
+        format = env[Grape::Env::API_FORMAT] || options[:format]
+        formatter = Grape::ErrorFormatter.formatter_for(format, options[:error_formatters], options[:default_error_formatter])
+        return formatter.call(message, backtrace, options, env, original_exception) if formatter
+
+        throw :error,
+              status: 406,
+              message: "The requested format '#{format}' is not supported.",
+              backtrace: backtrace,
+              original_exception: original_exception
+      end
+
+      def find_handler(klass)
+        rescue_handler_for_base_only_class(klass) ||
+          rescue_handler_for_class_or_its_ancestor(klass) ||
+          rescue_handler_for_grape_exception(klass) ||
+          rescue_handler_for_any_class(klass) ||
+          raise
       end
-      
+
       def error_response(error = {})
-        Rack::Response.new([(error[:message] || options[:default_message])], error[:status] || 403, error[:headers] || {}).finish
+        status = error[:status] || options[:default_status]
+        env[Grape::Env::API_ENDPOINT].status(status) # error! may not have been called
+        message = error[:message] || options[:default_message]
+        headers = { Rack::CONTENT_TYPE => content_type }.tap do |h|
+          h.merge!(error[:headers]) if error[:headers].is_a?(Hash)
+        end
+        backtrace = error[:backtrace] || error[:original_exception]&.backtrace || []
+        original_exception = error.is_a?(Exception) ? error : error[:original_exception] || nil
+        rack_response(status, headers, format_message(message, backtrace, original_exception))
+      end
+
+      def default_rescue_handler(exception)
+        error_response(message: exception.message, backtrace: exception.backtrace, original_exception: exception)
+      end
+
+      def rescue_handler_for_base_only_class(klass)
+        error, handler = options[:base_only_rescue_handlers]&.find { |err, _handler| klass == err }
+
+        return unless error
+
+        handler || method(:default_rescue_handler)
+      end
+
+      def rescue_handler_for_class_or_its_ancestor(klass)
+        error, handler = options[:rescue_handlers]&.find { |err, _handler| klass <= err }
+
+        return unless error
+
+        handler || method(:default_rescue_handler)
+      end
+
+      def rescue_handler_for_grape_exception(klass)
+        return unless klass <= Grape::Exceptions::Base
+        return method(:error_response) if klass == Grape::Exceptions::InvalidVersionHeader
+        return unless options[:rescue_grape_exceptions] || !options[:rescue_all]
+
+        options[:grape_exceptions_rescue_handler] || method(:error_response)
+      end
+
+      def rescue_handler_for_any_class(klass)
+        return unless klass <= StandardError
+        return unless options[:rescue_all] || options[:rescue_grape_exceptions]
+
+        options[:all_rescue_handler] || method(:default_rescue_handler)
+      end
+
+      def run_rescue_handler(handler, error, endpoint)
+        if handler.instance_of?(Symbol)
+          raise NoMethodError, "undefined method '#{handler}'" unless respond_to?(handler)
+
+          handler = public_method(handler)
+        end
+
+        response = catch(:error) do
+          handler.arity.zero? ? endpoint.instance_exec(&handler) : endpoint.instance_exec(error, &handler)
+        end
+
+        if error?(response)
+          error_response(response)
+        elsif response.is_a?(Rack::Response)
+          response
+        else
+          run_rescue_handler(method(:default_rescue_handler), Grape::Exceptions::InvalidResponse.new, endpoint)
+        end
+      end
+
+      def error!(message, status = options[:default_status], headers = {}, backtrace = [], original_exception = nil)
+        env[Grape::Env::API_ENDPOINT].status(status) # not error! inside route
+        rack_response(
+          status, headers.reverse_merge(Rack::CONTENT_TYPE => content_type),
+          format_message(message, backtrace, original_exception)
+        )
+      end
+
+      def error?(response)
+        return false unless response.is_a?(Hash)
+
+        response.key?(:message) && response.key?(:status) && response.key?(:headers)
       end
     end
   end
-end
+end

data/lib/grape/middleware/filter.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Grape
+  module Middleware
+    # This is a simple middleware for adding before and after filters
+    # to Grape APIs. It is used like so:
+    #
+    #     use Grape::Middleware::Filter, before: -> { do_something }, after: -> { do_something }
+    class Filter < Base
+      def before
+        app.instance_eval(&options[:before]) if options[:before]
+      end
+
+      def after
+        app.instance_eval(&options[:after]) if options[:after]
+      end
+    end
+  end
+end