grape-security 0.8.0

data/lib/grape/error_formatter/base.rb

@@ -0,0 +1,31 @@
+module Grape
+  module ErrorFormatter
+    module Base
+      class << self
+        FORMATTERS = {
+          serializable_hash: Grape::ErrorFormatter::Json,
+          json: Grape::ErrorFormatter::Json,
+          jsonapi: Grape::ErrorFormatter::Json,
+          txt: Grape::ErrorFormatter::Txt,
+          xml: Grape::ErrorFormatter::Xml
+        }
+
+        def formatters(options)
+          FORMATTERS.merge(options[:error_formatters] || {})
+        end
+
+        def formatter_for(api_format, options = {})
+          spec = formatters(options)[api_format]
+          case spec
+          when nil
+            options[:default_error_formatter] || Grape::ErrorFormatter::Txt
+          when Symbol
+            method(spec)
+          else
+            spec
+          end
+        end
+      end
+    end
+  end
+end

data/lib/grape/error_formatter/json.rb

@@ -0,0 +1,15 @@
+module Grape
+  module ErrorFormatter
+    module Json
+      class << self
+        def call(message, backtrace, options = {}, env = nil)
+          result = message.is_a?(Hash) ? message : { error: message }
+          if (options[:rescue_options] || {})[:backtrace] && backtrace && !backtrace.empty?
+            result = result.merge(backtrace: backtrace)
+          end
+          MultiJson.dump(result)
+        end
+      end
+    end
+  end
+end

data/lib/grape/error_formatter/txt.rb

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

data/lib/grape/error_formatter/xml.rb

@@ -0,0 +1,15 @@
+module Grape
+  module ErrorFormatter
+    module Xml
+      class << self
+        def call(message, backtrace, options = {}, env = nil)
+          result = message.is_a?(Hash) ? message : { message: message }
+          if (options[:rescue_options] || {})[:backtrace] && backtrace && !backtrace.empty?
+            result = result.merge(backtrace: backtrace)
+          end
+          result.respond_to?(:to_xml) ? result.to_xml(root: :error) : result.to_s
+        end
+      end
+    end
+  end
+end

data/lib/grape/exceptions/base.rb

@@ -0,0 +1,66 @@
+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
+
+      def initialize(args = {})
+        @status = args[:status] || nil
+        @message = args[:message] || nil
+        @headers = args[:headers] || nil
+      end
+
+      def [](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 = {})
+        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|
+            message <<  "\n#{detail_array[0]}:\n  #{detail_array[1]}" unless detail_array[1].blank?
+            message
+          end
+        else
+          short_message
+        end
+      end
+
+      def problem(key, attributes)
+        translate_message("#{key}.problem", attributes)
+      end
+
+      def summary(key, attributes)
+        translate_message("#{key}.summary", attributes)
+      end
+
+      def resolution(key, attributes)
+        translate_message("#{key}.resolution", attributes)
+      end
+
+      def translate_attribute(key, options = {})
+        translate("#{BASE_ATTRIBUTES_KEY}.#{key}", { default: key }.merge(options))
+      end
+
+      def translate_message(key, options = {})
+        translate("#{BASE_MESSAGES_KEY}.#{key}", { default: '' }.merge(options))
+      end
+
+      def 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

@@ -0,0 +1,10 @@
+# encoding: utf-8
+module Grape
+  module Exceptions
+    class InvalidFormatter < Base
+      def initialize(klass, 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

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

data/lib/grape/exceptions/invalid_with_option_for_represent.rb

@@ -0,0 +1,10 @@
+# encoding: utf-8
+module Grape
+  module Exceptions
+    class InvalidWithOptionForRepresent < Base
+      def initialize
+        super(message: compose_message("invalid_with_option_for_represent"))
+      end
+    end
+  end
+end

data/lib/grape/exceptions/missing_mime_type.rb

@@ -0,0 +1,10 @@
+# encoding: utf-8
+module Grape
+  module Exceptions
+    class MissingMimeType < Base
+      def initialize(new_format)
+        super(message: compose_message("missing_mime_type", new_format: new_format))
+      end
+    end
+  end
+end

data/lib/grape/exceptions/missing_option.rb

@@ -0,0 +1,10 @@
+# encoding: utf-8
+module Grape
+  module Exceptions
+    class MissingOption < Base
+      def initialize(option)
+        super(message: compose_message("missing_option", option: option))
+      end
+    end
+  end
+end

data/lib/grape/exceptions/missing_vendor_option.rb

@@ -0,0 +1,10 @@
+# encoding: utf-8
+module Grape
+  module Exceptions
+    class MissingVendorOption < Base
+      def initialize
+        super(message: compose_message("missing_vendor_option"))
+      end
+    end
+  end
+end

data/lib/grape/exceptions/unknown_options.rb

@@ -0,0 +1,10 @@
+# encoding: utf-8
+module Grape
+  module Exceptions
+    class UnknownOptions < Base
+      def initialize(options)
+        super(message: compose_message("unknown_options", options: options))
+      end
+    end
+  end
+end

data/lib/grape/exceptions/unknown_validator.rb

@@ -0,0 +1,10 @@
+# encoding: utf-8
+module Grape
+  module Exceptions
+    class UnknownValidator < Base
+      def initialize(validator_type)
+        super(message: compose_message("unknown_validator", validator_type: validator_type))
+      end
+    end
+  end
+end

data/lib/grape/exceptions/validation.rb

@@ -0,0 +1,26 @@
+require 'grape/exceptions/base'
+
+module Grape
+  module Exceptions
+    class Validation < Grape::Exceptions::Base
+      attr_accessor :param
+
+      def initialize(args = {})
+        raise "Param is missing:" unless args.key? :param
+        @param = args[:param]
+        args[:message] = translate_message(args[:message_key]) if args.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

@@ -0,0 +1,31 @@
+module Grape
+  module Formatter
+    module Base
+      class << self
+        FORMATTERS = {
+          json: Grape::Formatter::Json,
+          jsonapi: Grape::Formatter::Json,
+          serializable_hash: Grape::Formatter::SerializableHash,
+          txt: Grape::Formatter::Txt,
+          xml: Grape::Formatter::Xml
+        }
+
+        def formatters(options)
+          FORMATTERS.merge(options[:formatters] || {})
+        end
+
+        def formatter_for(api_format, options = {})
+          spec = formatters(options)[api_format]
+          case spec
+          when nil
+            lambda { |obj, env| obj }
+          when Symbol
+            method(spec)
+          else
+            spec
+          end
+        end
+      end
+    end
+  end
+end

data/lib/grape/formatter/json.rb

@@ -0,0 +1,12 @@
+module Grape
+  module Formatter
+    module Json
+      class << self
+        def call(object, env)
+          return object.to_json if object.respond_to?(:to_json)
+          MultiJson.dump(object)
+        end
+      end
+    end
+  end
+end

data/lib/grape/formatter/serializable_hash.rb

@@ -0,0 +1,35 @@
+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)
+          return object.to_json if object.respond_to?(:to_json)
+          MultiJson.dump(object)
+        end
+
+        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 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
+end

data/lib/grape/formatter/txt.rb

@@ -0,0 +1,11 @@
+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
+end

data/lib/grape/formatter/xml.rb

@@ -0,0 +1,12 @@
+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
+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