grape 0.9.0 → 0.10.0

data/lib/grape/exceptions/unknown_validator.rb

@@ -3,7 +3,7 @@ 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

data/lib/grape/exceptions/validation.rb

@@ -6,7 +6,7 @@ module Grape
       attr_accessor :params
 
       def initialize(args = {})
-        raise "Params are missing:" unless args.key? :params
+        fail 'Params are missing:' unless args.key? :params
         @params = args[:params]
         args[:message] = translate_message(args[:message_key]) if args.key? :message_key
         super

data/lib/grape/exceptions/validation_errors.rb

@@ -45,8 +45,8 @@ module Grape
 
       def full_message(attributes, error)
         I18n.t(
-          "grape.errors.format".to_sym,
-          default: "%{attributes} %{message}",
+          'grape.errors.format'.to_sym,
+          default: '%{attributes} %{message}',
           attributes: attributes.count == 1 ? translate_attribute(attributes.first) : translate_attributes(attributes),
           message: error.message
         )

data/lib/grape/formatter/serializable_hash.rb

@@ -19,7 +19,7 @@ module Grape
           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 }
+            object.map(&:serializable_hash)
           elsif object.kind_of?(Hash)
             object.inject({}) do |h, (k, v)|
               h[k] = serialize(v)

data/lib/grape/formatter/xml.rb

@@ -4,7 +4,7 @@ module Grape
       class << self
         def call(object, env)
           return object.to_xml if object.respond_to?(:to_xml)
-          raise Grape::Exceptions::InvalidFormatter.new(object.class, 'xml')
+          fail Grape::Exceptions::InvalidFormatter.new(object.class, 'xml')
         end
       end
     end

data/lib/grape/locale/en.yml

@@ -6,6 +6,7 @@ en:
         coerce: 'is invalid'
         presence: 'is missing'
         regexp: 'is invalid'
+        blank: 'is empty'
         values: 'does not have a valid value'
         missing_vendor_option:
           problem: 'missing :vendor option.'
@@ -31,4 +32,5 @@ en:
         mutual_exclusion: 'are mutually exclusive'
         at_least_one: 'are missing, at least one parameter must be provided'
         exactly_one: 'are missing, exactly one parameter must be provided'
+        all_or_none: 'provide all or none of parameters'
 

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

@@ -1,33 +1,38 @@
 require 'rack/auth/basic'
+require 'active_support/concern'
 
 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]
+        extend ActiveSupport::Concern
+
+        module ClassMethods
+          # Add an authentication type to the API. Currently
+          # only `:http_basic`, `:http_digest` are supported.
+          def auth(type = nil, options = {}, &block)
+            if type
+              namespace_inheritable(:auth, { type: type.to_sym, proc: block }.merge(options))
+              use Grape::Middleware::Auth::Base, namespace_inheritable(:auth)
+            else
+              namespace_inheritable(:auth)
+            end
           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
+          # 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
+          def http_digest(options = {}, &block)
+            options[:realm] ||= 'API Authorization'
+            options[:opaque] ||= 'secret'
+            auth :http_digest, options, &block
+          end
         end
       end
     end

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

@@ -10,7 +10,7 @@ module Grape
 
         def auth_strategies
           @auth_strategies ||= {
-            http_basic: StrategyInfo.new(Rack::Auth::Basic, ->(settings) {[settings[:realm]] }),
+            http_basic: StrategyInfo.new(Rack::Auth::Basic, ->(settings) { [settings[:realm]] }),
             http_digest: StrategyInfo.new(Rack::Auth::Digest::MD5, ->(settings) { [settings[:realm], settings[:opaque]] })
           }
         end

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

@@ -2,13 +2,11 @@ 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

data/lib/grape/middleware/base.rb

@@ -53,9 +53,9 @@ module Grape
       end
 
       def mime_types
-        content_types.each_with_object({}) { |(k, v), types_without_params|
+        content_types.each_with_object({}) do |(k, v), types_without_params|
           types_without_params[k] = v.split(';').first
-        }.invert
+        end.invert
       end
     end
   end

data/lib/grape/middleware/error.rb

@@ -6,7 +6,7 @@ module Grape
       def default_options
         {
           default_status: 500, # default status returned on error
-          default_message: "",
+          default_message: '',
           format: :txt,
           formatters: {},
           error_formatters: {},

data/lib/grape/middleware/formatter.rb

@@ -26,7 +26,7 @@ module Grape
       def after
         status, headers, bodies = *@app_response
         # allow content-type to be explicitly overwritten
-        api_format = mime_types[headers["Content-Type"]] || env['api.format']
+        api_format = mime_types[headers['Content-Type']] || env['api.format']
         formatter = Grape::Formatter::Base.formatter_for api_format, options
         begin
           bodymap = bodies.collect do |body|
@@ -48,9 +48,9 @@ module Grape
       # store read input in env['api.request.input']
       def read_body_input
         if (request.post? || request.put? || request.patch? || request.delete?) &&
-          (!request.form_data? || !request.media_type) &&
-          (!request.parseable_data?) &&
-          (request.content_length.to_i > 0 || request.env['HTTP_TRANSFER_ENCODING'] == 'chunked')
+           (!request.form_data? || !request.media_type) &&
+           (!request.parseable_data?) &&
+           (request.content_length.to_i > 0 || request.env['HTTP_TRANSFER_ENCODING'] == 'chunked')
 
           if (input = env['rack.input'])
             input.rewind
@@ -113,7 +113,7 @@ module Grape
       end
 
       def format_from_params
-        fmt = Rack::Utils.parse_nested_query(env['QUERY_STRING'])["format"]
+        fmt = Rack::Utils.parse_nested_query(env['QUERY_STRING'])['format']
         # avoid symbol memory leak on an unknown format
         return fmt.to_sym if content_type_for(fmt)
         fmt

data/lib/grape/middleware/versioner.rb

@@ -24,7 +24,7 @@ module Grape
         when :accept_version_header
           AcceptVersionHeader
         else
-          raise Grape::Exceptions::InvalidVersionerOption.new(strategy)
+          fail Grape::Exceptions::InvalidVersionerOption.new(strategy)
         end
       end
     end

data/lib/grape/middleware/versioner/header.rb

@@ -52,9 +52,9 @@ module Grape
             env['api.subtype'] = subtype
 
             if /\Avnd\.([a-z0-9*.]+)(?:-([a-z0-9*\-.]+))?(?:\+([a-z0-9*\-.+]+))?\z/ =~ subtype
-              env['api.vendor']  = $1
-              env['api.version'] = $2
-              env['api.format']  = $3  # weird that Grape::Middleware::Formatter also does this
+              env['api.vendor']  = Regexp.last_match[1]
+              env['api.version'] = Regexp.last_match[2]
+              env['api.format']  = Regexp.last_match[3]  # weird that Grape::Middleware::Formatter also does this
             end
           # If none of the available content types are acceptable:
           elsif strict?

data/lib/grape/middleware/versioner/param.rb

@@ -21,7 +21,7 @@ module Grape
       class Param < Base
         def default_options
           {
-            parameter: "apiver"
+            parameter: 'apiver'
           }
         end
 
@@ -30,7 +30,7 @@ module Grape
           potential_version = Rack::Utils.parse_nested_query(env['QUERY_STRING'])[paramkey]
           unless potential_version.nil?
             if options[:versions] && !options[:versions].find { |v| v.to_s == potential_version }
-              throw :error, status: 404, message: "404 API Version Not Found", headers: { 'X-Cascade' => 'pass' }
+              throw :error, status: 404, message: '404 API Version Not Found', headers: { 'X-Cascade' => 'pass' }
             end
             env['api.version'] = potential_version
             env['rack.request.query_hash'].delete(paramkey) if env.key? 'rack.request.query_hash'

data/lib/grape/middleware/versioner/path.rb

@@ -35,7 +35,7 @@ module Grape
           potential_version = pieces[1]
           if potential_version =~ options[:pattern]
             if options[:versions] && !options[:versions].find { |v| v.to_s == potential_version }
-              throw :error, status: 404, message: "404 API Version Not Found"
+              throw :error, status: 404, message: '404 API Version Not Found'
             end
             env['api.version'] = potential_version
           end

data/lib/grape/namespace.rb

@@ -13,7 +13,7 @@ module Grape
     end
 
     def self.joined_space(settings)
-      settings.gather(:namespace).map(&:space).join("/")
+      (settings || []).map(&:space).join('/')
     end
 
     def self.joined_space_path(settings)

data/lib/grape/path.rb

@@ -13,13 +13,17 @@ module Grape
     end
 
     def mount_path
-      split_setting(:mount_path, '/')
+      settings[:mount_path]
     end
 
     def root_prefix
       split_setting(:root_prefix, '/')
     end
 
+    def uses_specific_format?
+      !!(settings[:format] && settings[:content_types].size == 1)
+    end
+
     def uses_path_versioning?
       !!(settings[:version] && settings[:version_options][:using] == :path)
     end
@@ -33,7 +37,9 @@ module Grape
     end
 
     def suffix
-      if !uses_path_versioning? || (has_namespace? || has_path?)
+      if uses_specific_format?
+        ''
+      elsif !uses_path_versioning? || (has_namespace? || has_path?)
         '(.:format)'
       else
         '(/.:format)'
@@ -64,7 +70,7 @@ module Grape
 
     def split_setting(key, delimiter)
       return if settings[key].nil?
-      settings[key].to_s.split("/")
+      settings[key].to_s.split('/')
     end
   end
 end

data/lib/grape/util/content_types.rb

@@ -2,17 +2,25 @@ module Grape
   module ContentTypes
     # Content types are listed in order of preference.
     CONTENT_TYPES = ActiveSupport::OrderedHash[
-      :xml,  'application/xml',
-      :serializable_hash, 'application/json',
-      :json, 'application/json',
-      :jsonapi, 'application/vnd.api+json',
-      :atom, 'application/atom+xml',
-      :rss,  'application/rss+xml',
-      :txt,  'text/plain',
+                    :xml,  'application/xml',
+                    :serializable_hash, 'application/json',
+                    :json, 'application/json',
+                    :binary, 'application/octet-stream',
+                    :txt,  'text/plain'
    ]
 
+    def self.content_types_for_settings(settings)
+      return nil if settings.nil? || settings.blank?
+
+      settings.each_with_object(ActiveSupport::OrderedHash.new) { |value, result| result.merge!(value) }
+    end
+
     def self.content_types_for(from_settings)
-      from_settings || Grape::ContentTypes::CONTENT_TYPES
+      if from_settings.present?
+        from_settings
+      else
+        Grape::ContentTypes::CONTENT_TYPES
+      end
     end
   end
 end

data/lib/grape/util/inheritable_setting.rb

@@ -0,0 +1,74 @@
+module Grape
+  module Util
+    class InheritableSetting
+      attr_accessor :route, :api_class, :namespace, :namespace_inheritable, :namespace_stackable
+      attr_accessor :parent, :point_in_time_copies
+
+      def self.global
+        @global ||= {}
+      end
+
+      def self.reset_global! # only for testing
+        @global = {}
+      end
+
+      def initialize
+        self.route = {}
+        self.api_class = {}
+        self.namespace = InheritableValues.new # only inheritable from a parent when
+        # used with a mount, or should every API::Class be a seperate namespace by default?
+        self.namespace_inheritable = InheritableValues.new
+        self.namespace_stackable = StackableValues.new
+
+        self.point_in_time_copies = []
+
+        self.parent = nil
+      end
+
+      def global
+        self.class.global
+      end
+
+      def inherit_from(parent)
+        return if parent.nil?
+
+        self.parent = parent
+
+        namespace_inheritable.inherited_values = parent.namespace_inheritable
+        namespace_stackable.inherited_values = parent.namespace_stackable
+        self.route = parent.route.merge(route)
+
+        point_in_time_copies.map { |cloned_one| cloned_one.inherit_from parent }
+      end
+
+      def point_in_time_copy
+        self.class.new.tap do |new_setting|
+          point_in_time_copies << new_setting
+          new_setting.point_in_time_copies = []
+
+          new_setting.namespace = namespace.clone
+          new_setting.namespace_inheritable = namespace_inheritable.clone
+          new_setting.namespace_stackable = namespace_stackable.clone
+          new_setting.route = route.clone
+          new_setting.api_class = api_class
+
+          new_setting.inherit_from(parent)
+        end
+      end
+
+      def route_end
+        @route = {}
+      end
+
+      def to_hash
+        {
+          global: global.clone,
+          route: route.clone,
+          namespace: namespace.to_hash,
+          namespace_inheritable: namespace_inheritable.to_hash,
+          namespace_stackable: namespace_stackable.to_hash
+        }
+      end
+    end
+  end
+end

data/lib/grape/util/inheritable_values.rb

@@ -0,0 +1,51 @@
+module Grape
+  module Util
+    class InheritableValues
+      attr_accessor :inherited_values
+      attr_accessor :new_values
+
+      def initialize(inherited_values = {})
+        self.inherited_values = inherited_values
+        self.new_values = {}
+      end
+
+      def [](name)
+        values[name]
+      end
+
+      def []=(name, value)
+        new_values[name] = value
+      end
+
+      def delete(key)
+        new_values.delete key
+      end
+
+      def merge(new_hash)
+        values.merge(new_hash)
+      end
+
+      def keys
+        (new_values.keys + inherited_values.keys).sort.uniq
+      end
+
+      def to_hash
+        values.clone
+      end
+
+      def initialize_copy(other)
+        super
+        self.inherited_values = other.inherited_values
+        self.new_values = other.new_values.deep_dup
+      end
+
+      attr_writer :new_values
+
+      protected
+
+      def values
+        @inherited_values.merge(@new_values)
+      end
+    end
+  end
+end