grape 0.6.0 → 0.6.1

data/lib/grape/cookies.rb

@@ -13,12 +13,10 @@ module Grape
     end
 
     def write(header)
-      @cookies.select { |key, value|
-        @send_cookies[key] == true
-      }.each { |name, value|
-        cookie_value = value.is_a?(Hash) ? value : { :value => value }
+      @cookies.select { |key, value| @send_cookies[key] == true }.each do |name, value|
+        cookie_value = value.is_a?(Hash) ? value : { value: value }
         Rack::Utils.set_cookie_header! header, name, cookie_value
-      }
+      end
     end
 
     def [](name)
@@ -35,7 +33,7 @@ module Grape
     end
 
     def delete(name, opts = {})
-      options = opts.merge({ :value => 'deleted', :expires => Time.at(0) })
+      options = opts.merge(value: 'deleted', expires: Time.at(0))
       self.[]=(name, options)
     end
 

data/lib/grape/endpoint.rb

@@ -52,15 +52,15 @@ module Grape
     end
 
     def require_option(options, key)
-      options.has_key?(key) or raise Grape::Exceptions::MissingOption.new(key)
+      raise Grape::Exceptions::MissingOption.new(key) unless options.has_key?(key)
     end
 
     def method_name
-      [ options[:method],
-        Namespace.joined_space(settings),
-        settings.gather(:mount_path).join('/'),
-        options[:path].join('/')
-      ].join(" ")
+      [options[:method],
+       Namespace.joined_space(settings),
+       settings.gather(:mount_path).join('/'),
+       options[:path].join('/')
+     ].join(" ")
     end
 
     def routes
@@ -72,15 +72,15 @@ module Grape
         endpoints.each { |e| e.mount_in(route_set) }
       else
         routes.each do |route|
-          methods = [ route.route_method ]
-          if ! settings[:do_not_route_head] && route.route_method == "GET"
+          methods = [route.route_method]
+          if !settings[:do_not_route_head] && route.route_method == "GET"
             methods << "HEAD"
           end
           methods.each do |method|
             route_set.add_route(self, {
-              :path_info => route.route_compiled,
-              :request_method => method,
-            }, { :route_info => route })
+              path_info: route.route_compiled,
+              request_method: method,
+            }, { route_info: route })
           end
         end
       end
@@ -105,21 +105,21 @@ module Grape
           regex = Rack::Mount::RegexpWithNamedGroups.new(path)
           path_params = {}
           # named parameters in the api path
-          named_params = regex.named_captures.map { |nc| nc[0] } - [ 'version', 'format' ]
+          named_params = regex.named_captures.map { |nc| nc[0] } - %w{ version format }
           named_params.each { |named_param| path_params[named_param] = "" }
           # route parameters declared via desc or appended to the api declaration
           route_params = (options[:route_options][:params] || {})
           path_params.merge!(route_params)
           request_method = (method.to_s.upcase unless method == :any)
-          routes << Route.new(options[:route_options].clone.merge({
-            :prefix => settings[:root_prefix],
-            :version => settings[:version] ? settings[:version].join('|') : nil,
-            :namespace => namespace,
-            :method => request_method,
-            :path => prepared_path,
-            :params => path_params,
-            :compiled => path,
-            })
+          routes << Route.new(options[:route_options].clone.merge(
+            prefix: settings[:root_prefix],
+            version: settings[:version] ? settings[:version].join('|') : nil,
+            namespace: namespace,
+            method: request_method,
+            path: prepared_path,
+            params: path_params,
+            compiled: path,
+          )
           )
         end
       end
@@ -151,7 +151,7 @@ module Grape
         options[:app].call(env)
       else
         builder = build_middleware
-        builder.run options[:app] || lambda{|env| self.run(env) }
+        builder.run options[:app] || lambda { |arg| run(arg) }
         builder.call(env)
       end
     end
@@ -187,10 +187,10 @@ module Grape
             output_key = options[:stringify] ? parent.to_s : parent.to_sym
             if params.key?(parent) || options[:include_missing]
               hash[output_key] = if children
-                declared(params[parent] || {}, options, Array(children))
-              else
-                params[parent]
-              end
+                                   declared(params[parent] || {}, options, Array(children))
+                                 else
+                                   params[parent]
+                                 end
             end
           end
 
@@ -200,15 +200,17 @@ module Grape
     end
 
     # The API version as specified in the URL.
-    def version; env['api.version'] end
+    def version
+      env['api.version']
+    end
 
     # End the request and display an error to the
     # end user with the specified message.
     #
     # @param message [String] The message to display.
     # @param status [Integer] the HTTP Status Code. Defaults to 403.
-    def error!(message, status=403)
-      throw :error, :message => message, :status => status
+    def error!(message, status = 403)
+      throw :error, message: message, status: status
     end
 
     # Redirect to a new url.
@@ -217,7 +219,7 @@ module Grape
     # @param options [Hash] The options used when redirect.
     #                       :permanent, default true.
     def redirect(url, options = {})
-      merged_options = {:permanent => false }.merge(options)
+      merged_options = { permanent: false }.merge(options)
       if merged_options[:permanent]
         status 301
       else
@@ -240,10 +242,10 @@ module Grape
       else
         return @status if @status
         case request.request_method.to_s.upcase
-          when 'POST'
-            201
-          else
-            200
+        when 'POST'
+          201
+        else
+          200
         end
       end
     end
@@ -273,7 +275,7 @@ module Grape
     # @example
     #   cookies[:mycookie] = 'mycookie val'
     #   cookies['mycookie-string'] = 'mycookie string val'
-    #   cookies[:more] = { :value => '123', :expires => Time.at(0) }
+    #   cookies[:more] = { value: '123', expires: Time.at(0) }
     #   cookies.delete :more
     #
     def cookies
@@ -310,8 +312,8 @@ module Grape
     #
     #   get '/users/:id' do
     #     present User.find(params[:id]),
-    #       :with => API::Entities::User,
-    #       :admin => current_user.admin?
+    #       with: API::Entities::User,
+    #       admin: current_user.admin?
     #   end
     def present(*args)
       options = args.count > 1 ? args.extract_options! : {}
@@ -334,15 +336,15 @@ module Grape
       root = options.delete(:root)
 
       representation = if entity_class
-        embeds = {:env => env}
-        embeds[:version] = env['api.version'] if env['api.version']
-        entity_class.represent(object, embeds.merge(options))
-      else
-        object
-      end
+                         embeds = { env: env }
+                         embeds[:version] = env['api.version'] if env['api.version']
+                         entity_class.represent(object, embeds.merge(options))
+                       else
+                         object
+                       end
 
       representation = { root => representation } if root
-      representation = (@body || {}).merge({key => representation}) if key
+      representation = (@body || {}).merge(key => representation) if key
       body representation
     end
 
@@ -375,7 +377,7 @@ module Grape
       @header = {}
       @request = Grape::Request.new(@env)
 
-      self.extend helpers
+      extend helpers
       cookies.read(@request)
 
       run_filters befores
@@ -408,22 +410,22 @@ module Grape
 
       b.use Rack::Head
       b.use Grape::Middleware::Error,
-        :format => settings[:format],
-        :default_status => settings[:default_error_status] || 403,
-        :rescue_all => settings[:rescue_all],
-        :rescued_errors => aggregate_setting(:rescued_errors),
-        :default_error_formatter => settings[:default_error_formatter],
-        :error_formatters => settings[:error_formatters],
-        :rescue_options => settings[:rescue_options],
-        :rescue_handlers => merged_setting(:rescue_handlers)
+            format: settings[:format],
+            default_status: settings[:default_error_status] || 403,
+            rescue_all: settings[:rescue_all],
+            rescued_errors: aggregate_setting(:rescued_errors),
+            default_error_formatter: settings[:default_error_formatter],
+            error_formatters: settings[:error_formatters],
+            rescue_options: settings[:rescue_options],
+            rescue_handlers: merged_setting(:rescue_handlers)
 
       aggregate_setting(:middleware).each do |m|
         m = m.dup
         block = m.pop if m.last.is_a?(Proc)
         if block
-          b.use *m, &block
+          b.use(*m, &block)
         else
-          b.use *m
+          b.use(*m)
         end
       end
 
@@ -432,31 +434,33 @@ module Grape
 
       if settings[:version]
         b.use Grape::Middleware::Versioner.using(settings[:version_options][:using]), {
-          :versions        => settings[:version] ? settings[:version].flatten : nil,
-          :version_options => settings[:version_options],
-          :prefix          => settings[:root_prefix]
+          versions: settings[:version] ? settings[:version].flatten : nil,
+          version_options: settings[:version_options],
+          prefix: settings[:root_prefix]
         }
       end
 
       b.use Grape::Middleware::Formatter,
-        :format => settings[:format],
-        :default_format => settings[:default_format] || :txt,
-        :content_types => settings[:content_types],
-        :formatters => settings[:formatters],
-        :parsers => settings[:parsers]
+            format: settings[:format],
+            default_format: settings[:default_format] || :txt,
+            content_types: settings[:content_types],
+            formatters: settings[:formatters],
+            parsers: settings[:parsers]
 
       b
     end
 
     def helpers
       m = Module.new
-      settings.stack.each{|frame| m.send :include, frame[:helpers] if frame[:helpers]}
+      settings.stack.each do |frame|
+        m.send :include, frame[:helpers] if frame[:helpers]
+      end
       m
     end
 
     def aggregate_setting(key)
       settings.stack.inject([]) do |aggregate, frame|
-        aggregate += (frame[key] || [])
+        aggregate + (frame[key] || [])
       end
     end
 
@@ -468,12 +472,20 @@ module Grape
 
     def run_filters(filters)
       (filters || []).each do |filter|
-        instance_eval &filter
+        instance_eval(&filter)
       end
     end
 
-    def befores; aggregate_setting(:befores) end
-    def after_validations; aggregate_setting(:after_validations) end
-    def afters; aggregate_setting(:afters) end
+    def befores
+      aggregate_setting(:befores)
+    end
+
+    def after_validations
+      aggregate_setting(:after_validations)
+    end
+
+    def afters
+      aggregate_setting(:afters)
+    end
   end
 end

data/lib/grape/error_formatter/base.rb

@@ -5,10 +5,11 @@ module Grape
       class << self
 
         FORMATTERS = {
-          :serializable_hash => Grape::ErrorFormatter::Json,
-          :json => Grape::ErrorFormatter::Json,
-          :txt => Grape::ErrorFormatter::Txt,
-          :xml => Grape::ErrorFormatter::Xml
+          serializable_hash: Grape::ErrorFormatter::Json,
+          json: Grape::ErrorFormatter::Json,
+          jsonapi: Grape::ErrorFormatter::Json,
+          txt: Grape::ErrorFormatter::Txt,
+          xml: Grape::ErrorFormatter::Xml
         }
 
         def formatters(options)

data/lib/grape/error_formatter/json.rb

@@ -4,9 +4,9 @@ module Grape
       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 })
+          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

data/lib/grape/error_formatter/txt.rb

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

data/lib/grape/error_formatter/xml.rb

@@ -4,11 +4,11 @@ module Grape
       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 })
+          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
+          result.respond_to?(:to_xml) ? result.to_xml(root: :error) : result.to_s
         end
 
       end

data/lib/grape/exceptions/base.rb

@@ -15,20 +15,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
@@ -49,18 +50,17 @@ 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 = {})
         message = ::I18n.translate(key, options)
-        message.present? ? message : ::I18n.translate(key, options.merge({:locale => FALLBACK_LOCALE}))
+        message.present? ? message : ::I18n.translate(key, options.merge(locale: FALLBACK_LOCALE))
       end
 
     end

data/lib/grape/exceptions/incompatible_option_values.rb

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

@@ -4,7 +4,7 @@ module Grape
     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

data/lib/grape/exceptions/invalid_versioner_option.rb

@@ -5,7 +5,7 @@ module Grape
     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