grape 0.2.2 → 0.2.3

data/grape.gemspec

@@ -23,6 +23,7 @@ Gem::Specification.new do |s|
   s.add_runtime_dependency 'multi_xml'
   s.add_runtime_dependency 'hashie', '~> 1.2'
   s.add_runtime_dependency 'virtus'
+  s.add_runtime_dependency 'builder'
 
   s.add_development_dependency 'rake'
   s.add_development_dependency 'maruku'

data/lib/grape.rb

@@ -2,42 +2,63 @@ require 'rack'
 require 'rack/builder'
 
 module Grape
-  autoload :API,             'grape/api'
-  autoload :Endpoint,        'grape/endpoint'
-  autoload :MiddlewareStack, 'grape/middleware_stack'
-  autoload :Client,          'grape/client'
-  autoload :Route,           'grape/route'
-  autoload :Entity,          'grape/entity'
-  autoload :Cookies,         'grape/cookies'
-  autoload :Validations,     'grape/validations'
+  autoload :API,                 'grape/api'
+  autoload :Endpoint,            'grape/endpoint'
+  autoload :MiddlewareStack,     'grape/middleware_stack'
+  autoload :Client,              'grape/client'
+  autoload :Route,               'grape/route'
+  autoload :Entity,              'grape/entity'
+  autoload :Cookies,             'grape/cookies'
+  autoload :Validations,         'grape/validations'
 
   module Exceptions
-    autoload :Base, 'grape/exceptions/base'
+    autoload :Base,              'grape/exceptions/base'
+    autoload :ValidationError,   'grape/exceptions/validation_error'
+  end
+
+  module ErrorFormatter
+    autoload :Base,              'grape/error_formatter/base'
+    autoload :Json,              'grape/error_formatter/json'
+    autoload :Txt,               'grape/error_formatter/txt'
+    autoload :Xml,               'grape/error_formatter/xml'
+  end
+
+  module Formatter
+    autoload :Base,              'grape/formatter/base'
+    autoload :Json,              'grape/formatter/json'
+    autoload :SerializableHash,  'grape/formatter/serializable_hash'
+    autoload :Txt,               'grape/formatter/txt'
+    autoload :Xml,               'grape/formatter/xml'
+  end
+
+  module Parser
+    autoload :Base,              'grape/parser/base'
+    autoload :Json,              'grape/parser/json'
+    autoload :Xml,               'grape/parser/xml'
   end
-  autoload :ValidationError, 'grape/exceptions/validation_error'
 
   module Middleware
-    autoload :Base,      'grape/middleware/base'
-    autoload :Prefixer,  'grape/middleware/prefixer'
-    autoload :Versioner, 'grape/middleware/versioner'
-    autoload :Formatter, 'grape/middleware/formatter'
-    autoload :Error,     'grape/middleware/error'
+    autoload :Base,              'grape/middleware/base'
+    autoload :Prefixer,          'grape/middleware/prefixer'
+    autoload :Versioner,         'grape/middleware/versioner'
+    autoload :Formatter,         'grape/middleware/formatter'
+    autoload :Error,             'grape/middleware/error'
 
     module Auth
-      autoload :OAuth2, 'grape/middleware/auth/oauth2'
-      autoload :Basic,  'grape/middleware/auth/basic'
-      autoload :Digest,	'grape/middleware/auth/digest'
+      autoload :OAuth2,         'grape/middleware/auth/oauth2'
+      autoload :Basic,          'grape/middleware/auth/basic'
+      autoload :Digest,	        'grape/middleware/auth/digest'
     end
 
     module Versioner
-      autoload :Path,   'grape/middleware/versioner/path'
-      autoload :Header, 'grape/middleware/versioner/header'
-      autoload :Param,  'grape/middleware/versioner/param'
+      autoload :Path,           'grape/middleware/versioner/path'
+      autoload :Header,         'grape/middleware/versioner/header'
+      autoload :Param,          'grape/middleware/versioner/param'
     end
   end
 
   module Util
-    autoload :HashStack, 'grape/util/hash_stack'
+    autoload :HashStack,         'grape/util/hash_stack'
   end
 end
 

data/lib/grape/api.rb

@@ -130,10 +130,13 @@ module Grape
         new_format ? set(:format, new_format.to_sym) : settings[:format]
       end
 
-      # Specify the format for error messages.
-      # May be `:json` or `:txt` (default).
-      def error_format(new_format = nil)
-        new_format ? set(:error_format, new_format.to_sym) : settings[:error_format]
+      # Specify a custom formatter for a content-type.
+      def formatter(content_type, new_formatter)
+        settings.imbue(:formatters, content_type.to_sym => new_formatter)
+      end
+
+      def error_formatter(format, new_formatter)
+        settings.imbue(:error_formatters, format.to_sym => new_formatter)
       end
 
       # Specify additional content-types, e.g.:

data/lib/grape/endpoint.rb

@@ -11,9 +11,37 @@ module Grape
     attr_accessor :block, :options, :settings
     attr_reader :env, :request
 
+    class << self
+      # @api private
+      #
+      # Create an UnboundMethod that is appropriate for executing an endpoint
+      # route.
+      #
+      # The unbound method allows explicit calls to +return+ without raising a
+      # +LocalJumpError+. The method will be removed, but a +Proc+ reference to
+      # it will be returned. The returned +Proc+ expects a single argument: the
+      # instance of +Endpoint+ to bind to the method during the call.
+      #
+      # @param [String, Symbol] method_name
+      # @return [Proc]
+      # @raise [NameError] an instance method with the same name already exists
+      def generate_api_method(method_name, &block)
+        if instance_methods.include?(method_name.to_sym) || instance_methods.include?(method_name.to_s)
+          raise NameError.new("method #{method_name.inspect} already exists and cannot be used as an unbound method name")
+        end
+        define_method(method_name, &block)
+        method = instance_method(method_name)
+        remove_method(method_name)
+        proc { |endpoint_instance| method.bind(endpoint_instance).call }
+      end
+    end
+
     def initialize(settings, options = {}, &block)
       @settings = settings
-      @block = block
+      if block_given?
+        method_name = "#{options[:method]} #{settings.gather(:namespace).join( "/")} #{Array(options[:path]).join("/")}"
+        @block = self.class.generate_api_method(method_name, &block)
+      end
       @options = options
 
       raise ArgumentError, "Must specify :path option." unless options.key?(:path)
@@ -82,10 +110,20 @@ module Grape
     def prepare_path(path)
       parts = []
       parts << settings[:root_prefix] if settings[:root_prefix]
-      parts << ':version' if settings[:version] && settings[:version_options][:using] == :path
-      parts << namespace.to_s if namespace
-      parts << path.to_s if path && '/' != path
-      Rack::Mount::Utils.normalize_path(parts.join('/') + '(.:format)')
+
+      uses_path_versioning = settings[:version] && settings[:version_options][:using] == :path
+      namespace_is_empty = namespace && (namespace.to_s =~ /^\s*$/ || namespace.to_s == '/')
+      path_is_empty = path && (path.to_s =~ /^\s*$/ || path.to_s == '/')
+
+      parts << ':version' if uses_path_versioning
+      if !uses_path_versioning || (!namespace_is_empty || !path_is_empty)
+        parts << namespace.to_s if namespace
+        parts << path.to_s if path && '/' != path
+        format_suffix = '(.:format)'
+      else
+        format_suffix = '(/.:format)'
+      end
+      Rack::Mount::Utils.normalize_path(parts.join('/') + format_suffix)
     end
 
     def namespace
@@ -135,7 +173,7 @@ module Grape
       unless settings[:declared_params]
         raise ArgumentError, "Tried to filter for declared parameters but none exist."
       end
-      
+
       settings[:declared_params].inject({}){|h,k|
         output_key = options[:stringify] ? k.to_s : k.to_sym
         if params.key?(output_key) || options[:include_missing]
@@ -324,7 +362,7 @@ module Grape
 
       run_filters after_validations
 
-      response_text = instance_eval &self.block
+      response_text = @block.call(self)
       run_filters afters
       cookies.write(header)
 
@@ -339,7 +377,7 @@ module Grape
         :default_status => settings[:default_error_status] || 403,
         :rescue_all => settings[:rescue_all],
         :rescued_errors => aggregate_setting(:rescued_errors),
-        :format => settings[:error_format] || :txt,
+        :error_formatters => settings[:error_formatters],
         :rescue_options => settings[:rescue_options],
         :rescue_handlers => merged_setting(:rescue_handlers)
 
@@ -357,7 +395,8 @@ module Grape
       b.use Grape::Middleware::Formatter,
         :format => settings[:format],
         :default_format => settings[:default_format] || :txt,
-        :content_types => settings[:content_types]
+        :content_types => settings[:content_types],
+        :formatters => settings[:formatters]
 
       aggregate_setting(:middleware).each do |m|
         m = m.dup

data/lib/grape/entity.rb

@@ -306,7 +306,7 @@ module Grape
     # hash for the given data model and is used as the basis for serialization to
     # JSON and other formats.
     #
-    # @param options [Hash] Any options you pass in here will be known to the entity
+    # @param runtime_options [Hash] Any options you pass in here will be known to the entity
     #   representation, this is where you can trigger things from conditional options
     #   etc.
     def serializable_hash(runtime_options = {})

data/lib/grape/error_formatter/base.rb

@@ -0,0 +1,32 @@
+module Grape
+  module ErrorFormatter
+    module Base
+
+      class << self
+
+        FORMATTERS = {
+          :json => 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
+            lambda { |message, backtrace, options| message }
+          when Symbol
+            method(spec)
+          else
+            spec
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/grape/error_formatter/json.rb

@@ -0,0 +1,17 @@
+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,18 @@
+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,17 @@
+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/validation_error.rb

@@ -1,10 +1,14 @@
 require 'grape/exceptions/base'
 
-class ValidationError < Grape::Exceptions::Base
-  attr_accessor :param
+module Grape
+  module Exceptions
+    class ValidationError < Grape::Exceptions::Base
+      attr_accessor :param
 
-  def initialize(args = {})
-    @param = args[:param].to_s if args.has_key? :param
-    super
+      def initialize(args = {})
+        @param = args[:param].to_s if args.has_key? :param
+        super
+      end
+    end
   end
 end

data/lib/grape/formatter/base.rb

@@ -0,0 +1,33 @@
+module Grape
+  module Formatter
+    module Base
+
+      class << self
+
+        FORMATTERS = {
+          :json => 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,15 @@
+module Grape
+  module Formatter
+    module Json
+      class << self
+
+        def call(object, env)
+          return object if object.is_a?(String)
+          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({}) { |h,(k,v)| h[k] = serialize(v); h }
+            else
+              object
+            end
+          end
+      end
+    end
+  end
+end

data/lib/grape/formatter/txt.rb

@@ -0,0 +1,13 @@
+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,13 @@
+module Grape
+  module Formatter
+    module Xml
+      class << self
+
+        def call(object, env)
+          object.respond_to?(:to_xml) ? object.to_xml : object.to_s
+        end
+
+      end
+    end
+  end
+end