fragrant 0.0.1

data/vendor/grape/lib/grape/middleware/error.rb

@@ -0,0 +1,87 @@
+require 'grape/middleware/base'
+require 'multi_json'
+
+module Grape
+  module Middleware
+    class Error < Base
+      include Formats
+
+      def default_options
+      { 
+        :default_status => 403, # default status returned on error
+        :default_message => "",
+        :format => :txt,
+        :formatters => {},
+        :rescue_all => false, # true to rescue all exceptions        
+        :rescue_options => { :backtrace => false }, # true to display backtrace
+        :rescue_handlers => {}, # rescue handler blocks
+        :rescued_errors => []
+      }
+      end
+
+      def encode_json(message, 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
+      
+      def encode_txt(message, backtrace)
+        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
+
+      def call!(env)
+        @env = env
+        
+        begin
+          error_response(catch(:error){ 
+            return @app.call(@env) 
+          })
+        rescue Exception => e
+          is_rescuable = rescuable?(e.class)
+          if e.is_a?(Grape::Exceptions::Base) && !is_rescuable
+            handler = lambda {|e| error_response(e) }
+          else
+            raise unless is_rescuable
+            handler = options[:rescue_handlers][e.class] || options[:rescue_handlers][:all]
+          end
+          handler.nil? ? handle_error(e) : self.instance_exec(e, &handler)
+        end
+      end
+
+      def rescuable?(klass)
+        options[:rescue_all] || (options[:rescued_errors] || []).include?(klass)
+      end
+      
+      def handle_error(e)
+        error_response({ :message => e.message, :backtrace => e.backtrace })
+      end
+      
+      def error_response(error = {})
+        status = error[:status] || options[:default_status]
+        message = error[:message] || options[:default_message]
+        headers = {'Content-Type' => content_type}
+        headers.merge!(error[:headers]) if error[:headers].is_a?(Hash)
+        backtrace = error[:backtrace] || []
+        rack_response(format_message(message, backtrace, status), status, headers)
+      end
+
+      def rack_response(message, status = options[:default_status], headers = { 'Content-Type' => content_type })
+        Rack::Response.new([ message ], status, headers).finish
+      end
+            
+      def format_message(message, backtrace, status)
+        formatter = formatter_for(options[:format])
+        throw :error, :status => 406, :message => "The requested format #{options[:format]} is not supported." unless formatter
+        formatter.call(message, backtrace)
+      end
+      
+    end
+  end
+end

data/vendor/grape/lib/grape/middleware/filter.rb

@@ -0,0 +1,17 @@
+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 => lambda{ do_something }, after: => lambda{ 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

data/vendor/grape/lib/grape/middleware/formatter.rb

@@ -0,0 +1,81 @@
+require 'grape/middleware/base'
+
+module Grape
+  module Middleware
+    class Formatter < Base
+      include Formats
+
+      def default_options
+        {
+          :default_format => :txt,
+          :formatters => {},
+          :content_types => {},
+          :parsers => {}
+        }
+      end
+
+      def headers
+        env.dup.inject({}){|h,(k,v)| h[k.to_s.downcase[5..-1]] = v if k.to_s.downcase.start_with?('http_'); h}
+      end
+
+      def before
+        fmt = format_from_extension || options[:format] || format_from_header || options[:default_format]
+        if content_types.key?(fmt)
+          if !env['rack.input'].nil? and (body = env['rack.input'].read).strip.length != 0
+            parser = parser_for fmt
+            unless parser.nil?
+              begin
+                body = parser.call(body)
+                env['rack.request.form_hash'] = !env['rack.request.form_hash'].nil? ? env['rack.request.form_hash'].merge(body) : body
+                env['rack.request.form_input'] = env['rack.input']
+              rescue
+                # It's possible that it's just regular POST content -- just back off
+              end
+            end
+            env['rack.input'].rewind
+          end
+          env['api.format'] = fmt
+        else
+          throw :error, :status => 406, :message => 'The requested format is not supported.'
+        end
+      end
+
+      def format_from_extension
+        parts = request.path.split('.')
+        extension = parts.last.to_sym
+
+        if parts.size > 1 && content_types.key?(extension)
+          return extension
+        end
+        nil
+      end
+
+      def format_from_header
+        mime_array.each do |t|
+          if mime_types.key?(t)
+            return mime_types[t]
+          end
+        end
+        nil
+      end
+
+      def mime_array
+        accept = headers['accept'] or return []
+
+        accept.gsub(/\b/,'').scan(%r((\w+/[\w+.-]+)(?:(?:;[^,]*?)?;\s*q=([\d.]+))?)).sort_by { |_, q| -q.to_f }.map {|mime, _|
+          mime.sub(%r(vnd\.[^+]+\+), '')
+        }
+      end
+
+      def after
+        status, headers, bodies = *@app_response
+        formatter = formatter_for env['api.format']
+        bodymap = bodies.collect do |body|
+          formatter.call(body)
+        end
+        headers['Content-Type'] = content_types[env['api.format']] unless headers['Content-Type']
+        Rack::Response.new(bodymap, status, headers).to_a
+      end
+    end
+  end
+end

data/vendor/grape/lib/grape/middleware/prefixer.rb

@@ -0,0 +1,21 @@
+require 'rack/mount/utils'
+require 'grape'
+
+module Grape
+  module Middleware
+    class Prefixer < Base
+      def prefix
+        prefix = options[:prefix] || ""
+        prefix = Rack::Mount::Utils.normalize_path(prefix)
+        prefix
+      end
+      
+      def before
+        if env['PATH_INFO'].index(prefix) == 0
+          env['PATH_INFO'].sub!(prefix, '')
+          env['PATH_INFO'] = Rack::Mount::Utils.normalize_path(env['PATH_INFO'])
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+require 'grape/middleware/base'
+
+module Grape
+  module Middleware
+    module Versioner
+      # This middleware sets various version related rack environment variables
+      # based on the HTTP Accept header with the pattern:
+      # application/vnd.:vendor-:version+:format
+      #
+      # Example: For request header
+      #    Accept: application/vnd.mycompany-v1+json
+      #
+      # The following rack env variables are set:
+      #
+      #    env['api.type']    => 'application'
+      #    env['api.subtype'] => 'vnd.mycompany-v1+json'
+      #    env['api.vendor]   => 'mycompany'
+      #    env['api.version]  => 'v1'
+      #    env['api.format]   => 'format'
+      #
+      # If version does not match this route, then a 406 is throw with
+      # X-Cascade header to alert Rack::Mount to attempt the next matched
+      # route.
+      class Header < Base
+        def before
+          accept = env['HTTP_ACCEPT'] || ""
+
+          if options[:version_options] && options[:version_options].keys.include?(:strict) && options[:version_options][:strict]
+            if (is_accept_header_valid?(accept))  && options[:version_options][:using] == :header
+              throw :error, :status => 406, :headers => {'X-Cascade' => 'pass'}, :message => "406 API Version Not Found"
+            end
+          end
+          accept.strip.scan(/^(.+?)\/(.+?)$/) do |type, subtype|
+            env['api.type']    = type
+            env['api.subtype'] = subtype
+
+            subtype.scan(/vnd\.(.+)?-(.+)?\+(.*)?/) do |vendor, version, format|
+              is_vendored = options[:version_options] && options[:version_options][:vendor]
+              is_vendored_match = is_vendored ? options[:version_options][:vendor] == vendor : true
+
+              if (options[:versions] && !options[:versions].include?(version)) || !is_vendored_match
+                throw :error, :status => 406, :headers => {'X-Cascade' => 'pass'}, :message => "406 API Version Not Found"
+              end
+
+              env['api.version'] = version
+              env['api.vendor']  = vendor
+              env['api.format']  = format  # weird that Grape::Middleware::Formatter also does this
+            end
+          end
+        end
+
+        protected
+        def is_accept_header_valid?(header)
+          (header.strip =~ /application\/vnd\.(.+?)-(.+?)\+(.+?)/).nil?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+require 'grape/middleware/base'
+
+module Grape
+  module Middleware
+    module Versioner
+      # This middleware sets various version related rack environment variables
+      # based on the request parameters and removes that parameter from the 
+      # request parameters for subsequent middleware and API.
+      # If the version substring does not match any potential initialized
+      # versions, a 404 error is thrown.
+      # If the version substring is not passed the version (highest mounted)
+      # version will be used.
+      # 
+      # Example: For a uri path
+      #   /resource?apiver=v1
+      # 
+      # The following rack env variables are set and path is rewritten to
+      # '/resource':
+      # 
+      #   env['api.version'] => 'v1'
+      class Param < Base
+        def default_options
+          {
+            :parameter => "apiver"
+          }
+        end
+
+        def before
+          paramkey = options[:parameter]
+          potential_version = request.params[paramkey]
+
+          unless potential_version.nil?
+            if options[:versions] && !options[:versions].include?(potential_version)
+              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)
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+require 'grape/middleware/base'
+
+module Grape
+  module Middleware
+    module Versioner
+      # This middleware sets various version related rack environment variables
+      # based on the uri path and removes the version substring from the uri
+      # path. If the version substring does not match any potential initialized
+      # versions, a 404 error is thrown.
+      # 
+      # Example: For a uri path
+      #   /v1/resource
+      # 
+      # The following rack env variables are set and path is rewritten to
+      # '/resource':
+      # 
+      #   env['api.version'] => 'v1'
+      # 
+      class Path < Base
+        def default_options
+          {
+            :pattern => /.*/i
+          }
+        end
+
+        def before
+          pieces = env['PATH_INFO'].split('/')
+          potential_version = pieces[1]
+          if potential_version =~ options[:pattern]
+            if options[:versions] && !options[:versions].include?(potential_version)
+              throw :error, :status => 404, :message => "404 API Version Not Found"
+            end
+
+            truncated_path = "/#{pieces[2..-1].join('/')}"
+            env['api.version'] = potential_version
+            env['PATH_INFO'] = truncated_path
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# Versioners set env['api.version'] when a version is defined on an API and
+# on the requests. The current methods for determining version are:
+#
+#   :header - version from HTTP Accept header.
+#   :path   - version from uri. e.g. /v1/resource
+#
+# See individual classes for details.
+module Grape
+  module Middleware
+    module Versioner
+      extend self
+
+      # @param strategy [Symbol] :path or :header
+      # @return a middleware class based on strategy
+      def using(strategy)
+        case strategy
+        when :path
+          Path
+        when :header
+          Header
+        when :param
+          Param
+        else
+          raise ArgumentError.new("Unknown :using for versioner: #{strategy}")
+        end
+      end
+    end
+  end
+end

data/vendor/grape/lib/grape/route.rb

@@ -0,0 +1,23 @@
+module Grape
+
+  # A compiled route for inspection.
+  class Route
+  
+    def initialize(options = {})
+      @options = options || {}
+    end
+    
+    def method_missing(method_id, *arguments)
+      if match = /route_([_a-zA-Z]\w*)/.match(method_id.to_s)
+        @options[match.captures.last.to_sym]
+      else
+        super
+      end
+    end
+    
+    def to_s
+      "version=#{route_version}, method=#{route_method}, path=#{route_path}"
+    end
+    
+  end
+end

data/vendor/grape/lib/grape/util/deep_merge.rb

@@ -0,0 +1,23 @@
+class Hash
+  # deep_merge from rails
+  # activesupport/lib/active_support/core_ext/hash/deep_merge.rb
+  # Returns a new hash with +self+ and +other_hash+ merged recursively.
+  #
+  #   h1 = {:x => {:y => [4,5,6]}, :z => [7,8,9]}
+  #   h2 = {:x => {:y => [7,8,9]}, :z => "xyz"}
+  #
+  #   h1.deep_merge(h2) #=> { :x => {:y => [7, 8, 9]}, :z => "xyz" }
+  #   h2.deep_merge(h1) #=> { :x => {:y => [4, 5, 6]}, :z => [7, 8, 9] }
+  def deep_merge(other_hash)
+    dup.deep_merge!(other_hash)
+  end
+
+  # Same as +deep_merge+, but modifies +self+.
+  def deep_merge!(other_hash)
+    other_hash.each_pair do |k,v|
+      tv = self[k]
+      self[k] = tv.is_a?(Hash) && v.is_a?(Hash) ? tv.deep_merge(v) : v
+    end
+    self
+  end
+end

data/vendor/grape/lib/grape/util/hash_stack.rb

@@ -0,0 +1,100 @@
+module Grape
+  module Util
+    # HashStack is a stack of hashes. When retrieving a value, keys of the top
+    # hash on the stack take precendent over the lower keys.
+    class HashStack
+      # Unmerged array of hashes to represent the stack.
+      # The top of the stack is the last element.
+      attr_reader :stack
+
+      # TODO: handle aggregates
+      def initialize
+        @stack = [{}]
+      end
+
+      # Returns the top hash on the stack
+      def peek
+        @stack.last
+      end
+
+      # Add a new hash to the top of the stack.
+      # 
+      # @param hash [Hash] optional hash to be pushed. Defaults to empty hash
+      # @return [HashStack]
+      def push(hash = {})
+        @stack.push(hash)
+        self
+      end
+
+      def pop
+        @stack.pop
+      end
+
+      # Looks through the stack for the first frame that matches :key
+      # 
+      # @param key [Symbol] key to look for in hash frames
+      # @return value of given key after merging the stack
+      def get(key)
+        (@stack.length - 1).downto(0).each do |i|
+          return @stack[i][key] if @stack[i].key? key
+        end
+        nil
+      end
+      alias_method :[], :get
+
+      # Replace a value on the top hash of the stack.
+      #
+      # @param key [Symbol] The key to set.
+      # @param value [Object] The value to set.
+      def set(key, value)
+        peek[key.to_sym] = value
+      end
+      alias_method :[]=, :set
+
+      # Replace multiple values on the top hash of the stack.
+      # 
+      # @param hash [Hash] Hash of values to be merged in.
+      def update(hash)
+        peek.merge!(hash)
+        self
+      end
+
+      # Adds addition value into the top hash of the stack
+      def imbue(key, value)
+        current = peek[key.to_sym]
+        if current.is_a?(Array)
+          current.concat(value)
+        elsif current.is_a?(Hash)
+          current.merge!(value)
+        else
+          set(key, value)
+        end
+      end
+
+      # Prepend another HashStack's to self
+      def prepend(hash_stack)
+        @stack.unshift *hash_stack.stack
+        self
+      end
+
+      # Concatenate another HashStack's to self
+      def concat(hash_stack)
+        @stack.concat hash_stack.stack
+        self
+      end
+
+      def to_s
+        @stack.to_s
+      end
+
+      def clone
+        new_stack = HashStack.new
+        stack.each do |frame|
+          new_stack.push frame.clone
+        end
+        new_stack.stack.shift
+        new_stack
+      end
+    end
+  end
+end

data/vendor/grape/lib/grape/validations/coerce.rb

@@ -0,0 +1,61 @@
+module Grape
+
+  class API
+    Boolean = Virtus::Attribute::Boolean
+  end
+  
+  module Validations
+    
+    class CoerceValidator < SingleOptionValidator
+      def validate_param!(attr_name, params)
+        new_value = coerce_value(@option, params[attr_name])
+        if valid_type?(new_value)
+          params[attr_name] = new_value
+        else
+          raise ValidationError, :status => 400, :param => attr_name, :message => "invalid parameter: #{attr_name}"
+        end
+      end
+  
+      class InvalidValue; end
+    private
+    
+      def _valid_array_type?(type, values)
+        values.all? do |val|
+          _valid_single_type?(type, val)
+        end
+      end
+      
+      def _valid_single_type?(klass, val)
+        # allow nil, to ignore when a parameter is absent
+        return true if val.nil?
+        if klass == Virtus::Attribute::Boolean
+          val.is_a?(TrueClass) || val.is_a?(FalseClass)
+        elsif klass == Rack::Multipart::UploadedFile
+          val.is_a?(Hashie::Mash) && val.key?(:tempfile)
+        else
+          val.is_a?(klass)
+        end
+      end
+      
+      def valid_type?(val)
+        if @option.is_a?(Array)
+          _valid_array_type?(@option[0], val)
+        else
+          _valid_single_type?(@option, val)
+        end
+      end
+      
+      def coerce_value(type, val)
+        converter = Virtus::Attribute.build(:a, type)
+        converter.coerce(val)
+      
+      # not the prettiest but some invalid coercion can currently trigger
+      # errors in Virtus (see coerce_spec.rb)
+      rescue
+        InvalidValue.new
+      end
+      
+    end
+    
+  end
+end

data/vendor/grape/lib/grape/validations/presence.rb

@@ -0,0 +1,11 @@
+module Grape
+  module Validations
+    class PresenceValidator < Validator
+      def validate_param!(attr_name, params)
+        unless params.has_key?(attr_name)
+          raise ValidationError, :status => 400, :param => attr_name, :message => "missing parameter: #{attr_name}"
+        end
+      end
+    end
+  end
+end

data/vendor/grape/lib/grape/validations/regexp.rb

@@ -0,0 +1,13 @@
+module Grape
+  module Validations
+    
+    class RegexpValidator < SingleOptionValidator
+      def validate_param!(attr_name, params)
+        if params[attr_name] && !( params[attr_name].to_s =~ @option )
+          raise ValidationError, :status => 400, :param => attr_name, :message => "invalid parameter: #{attr_name}"
+        end
+      end
+    end
+
+  end
+end