grape 0.3.0 → 0.7.0

data/lib/grape/parser/base.rb

@@ -1,12 +1,11 @@
 module Grape
   module Parser
     module Base
-
       class << self
-
         PARSERS = {
-          :json => Grape::Parser::Json,
-          :xml => Grape::Parser::Xml
+          json: Grape::Parser::Json,
+          jsonapi: Grape::Parser::Json,
+          xml: Grape::Parser::Xml
         }
 
         def parsers(options)
@@ -24,7 +23,6 @@ module Grape
             spec
           end
         end
-
       end
     end
   end

data/lib/grape/parser/json.rb

@@ -2,11 +2,9 @@ module Grape
   module Parser
     module Json
       class << self
-
         def call(object, env)
           MultiJson.load(object)
         end
-
       end
     end
   end

data/lib/grape/parser/xml.rb

@@ -2,11 +2,9 @@ module Grape
   module Parser
     module Xml
       class << self
-
         def call(object, env)
           MultiXml.parse(object)
         end
-
       end
     end
   end

data/lib/grape/path.rb

@@ -0,0 +1,70 @@
+module Grape
+  class Path
+    def self.prepare(raw_path, namespace, settings)
+      Path.new(raw_path, namespace, settings).path_with_suffix
+    end
+
+    attr_reader :raw_path, :namespace, :settings
+
+    def initialize(raw_path, namespace, settings)
+      @raw_path = raw_path
+      @namespace = namespace
+      @settings = settings
+    end
+
+    def mount_path
+      split_setting(:mount_path, '/')
+    end
+
+    def root_prefix
+      split_setting(:root_prefix, '/')
+    end
+
+    def uses_path_versioning?
+      !!(settings[:version] && settings[:version_options][:using] == :path)
+    end
+
+    def has_namespace?
+      namespace && namespace.to_s =~ /^\S/ && namespace != '/'
+    end
+
+    def has_path?
+      raw_path && raw_path.to_s =~ /^\S/ && raw_path != '/'
+    end
+
+    def suffix
+      if !uses_path_versioning? || (has_namespace? || has_path?)
+        '(.:format)'
+      else
+        '(/.:format)'
+      end
+    end
+
+    def path
+      Rack::Mount::Utils.normalize_path(parts.join('/'))
+    end
+
+    def path_with_suffix
+      "#{path}#{suffix}"
+    end
+
+    def to_s
+      path_with_suffix
+    end
+
+    private
+
+    def parts
+      parts = [mount_path, root_prefix].compact
+      parts << ':version' if uses_path_versioning?
+      parts << namespace.to_s
+      parts << raw_path.to_s
+      parts.flatten.reject { |part| part == '/' }
+    end
+
+    def split_setting(key, delimiter)
+      return if settings[key].nil?
+      settings[key].to_s.split("/")
+    end
+  end
+end

data/lib/grape/route.rb

@@ -1,23 +1,27 @@
 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)
+      match = /route_([_a-zA-Z]\w*)/.match(method_id.to_s)
+      if match
         @options[match.captures.last.to_sym]
       else
         super
       end
     end
-    
+
     def to_s
       "version=#{route_version}, method=#{route_method}, path=#{route_path}"
     end
-    
+
+    private
+
+    def to_ary
+      nil
+    end
   end
 end

data/lib/grape/util/content_types.rb

@@ -5,10 +5,11 @@ module Grape
       :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',
-    ]
+   ]
 
     def self.content_types_for(from_settings)
       from_settings || Grape::ContentTypes::CONTENT_TYPES

data/lib/grape/util/deep_merge.rb

@@ -3,18 +3,18 @@ class Hash
   # 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 = {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] }
+  #     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|
+    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

data/lib/grape/util/hash_stack.rb

@@ -42,6 +42,17 @@ module Grape
       end
       alias_method :[], :get
 
+      # Looks through the stack for the first frame that matches :key
+      #
+      # @param key [Symbol] key to look for in hash frames
+      # @return true if key exists, false otherwise
+      def has_key?(key)
+        (@stack.length - 1).downto(0).each do |i|
+          return true if @stack[i].key? key
+        end
+        false
+      end
+
       # Replace a value on the top hash of the stack.
       #
       # @param key [Symbol] The key to set.
@@ -73,7 +84,7 @@ module Grape
 
       # Prepend another HashStack's to self
       def prepend(hash_stack)
-        @stack.unshift *hash_stack.stack
+        @stack.unshift(*hash_stack.stack)
         self
       end
 
@@ -89,7 +100,7 @@ module Grape
       # @param key [Symbol] The key to gather
       # @return [Array]
       def gather(key)
-        stack.map{|s| s[key] }.flatten.compact.uniq
+        stack.flat_map { |s| s[key] }.compact.uniq
       end
 
       def to_s

data/lib/grape/validations/coerce.rb

@@ -1,24 +1,23 @@
 module Grape
-
   class API
-    Boolean = Virtus::Attribute::Boolean
+    Boolean = Virtus::Attribute::Boolean # rubocop:disable ConstantName
   end
 
   module Validations
-
     class CoerceValidator < SingleOptionValidator
       def validate_param!(attr_name, params)
+        raise Grape::Exceptions::Validation, param: @scope.full_name(attr_name), message_key: :coerce unless params.is_a? Hash
         new_value = coerce_value(@option, params[attr_name])
         if valid_type?(new_value)
           params[attr_name] = new_value
         else
-          raise Grape::Exceptions::Validation, :status => 400,
-            :param => @scope.full_name(attr_name), :message_key => :coerce
+          raise Grape::Exceptions::Validation, param: @scope.full_name(attr_name), message_key: :coerce
         end
       end
 
       class InvalidValue; end
-    private
+
+      private
 
       def _valid_array_type?(type, values)
         values.all? do |val|
@@ -47,16 +46,18 @@ module Grape
       end
 
       def coerce_value(type, val)
-        converter = Virtus::Attribute.build(:a, type)
+        # Don't coerce things other than nil to Arrays or Hashes
+        return val || [] if type == Array
+        return val || {} if type == Hash
+
+        converter = Virtus::Attribute.build(type)
         converter.coerce(val)
 
       # not the prettiest but some invalid coercion can currently trigger
-      # errors in Virtus (see coerce_spec.rb)
+      # errors in Virtus (see coerce_spec.rb:75)
       rescue
         InvalidValue.new
       end
-
     end
-
   end
 end

data/lib/grape/validations/default.rb

@@ -0,0 +1,25 @@
+module Grape
+  module Validations
+    class DefaultValidator < Validator
+      def initialize(attrs, options, required, scope)
+        @default = options
+        super
+      end
+
+      def validate_param!(attr_name, params)
+        params[attr_name] = @default.is_a?(Proc) ? @default.call : @default unless params.has_key?(attr_name)
+      end
+
+      def validate!(params)
+        attrs = AttributesIterator.new(self, @scope, params)
+        parent_element = @scope.element
+        attrs.each do |resource_params, attr_name|
+          if resource_params[attr_name].nil?
+            validate_param!(attr_name, resource_params)
+            params[parent_element] = resource_params if parent_element && params[parent_element].nil?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/grape/validations/presence.rb

@@ -1,10 +1,14 @@
 module Grape
   module Validations
     class PresenceValidator < Validator
+      def validate!(params)
+        return unless @scope.should_validate?(params)
+        super
+      end
+
       def validate_param!(attr_name, params)
-        unless params.has_key?(attr_name)
-          raise Grape::Exceptions::Validation, :status => 400,
-            :param => @scope.full_name(attr_name), :message_key => :presence
+        unless params.respond_to?(:has_key?) && params.has_key?(attr_name)
+          raise Grape::Exceptions::Validation, param: @scope.full_name(attr_name), message_key: :presence
         end
       end
     end

data/lib/grape/validations/regexp.rb

@@ -1,14 +1,11 @@
 module Grape
   module Validations
-
     class RegexpValidator < SingleOptionValidator
       def validate_param!(attr_name, params)
-        if params[attr_name] && !( params[attr_name].to_s =~ @option )
-          raise Grape::Exceptions::Validation, :status => 400,
-            :param => @scope.full_name(attr_name), :message_key => :regexp
+        if params[attr_name] && !(params[attr_name].to_s =~ @option)
+          raise Grape::Exceptions::Validation, param: @scope.full_name(attr_name), message_key: :regexp
         end
       end
     end
-
   end
 end

data/lib/grape/validations/values.rb

@@ -0,0 +1,17 @@
+module Grape
+  module Validations
+    class ValuesValidator < Validator
+      def initialize(attrs, options, required, scope)
+        @values = options
+        @required = required
+        super
+      end
+
+      def validate_param!(attr_name, params)
+        if (params[attr_name] || @required) && !(@values.is_a?(Proc) ? @values.call : @values).include?(params[attr_name])
+          raise Grape::Exceptions::Validation, param: @scope.full_name(attr_name), message_key: :values
+        end
+      end
+    end
+  end
+end

data/lib/grape/validations.rb

@@ -1,7 +1,5 @@
 module Grape
-
   module Validations
-
     ##
     # All validators must inherit from this class.
     #
@@ -19,25 +17,40 @@ module Grape
       end
 
       def validate!(params)
-        params = @scope.params(params)
+        attributes = AttributesIterator.new(self, @scope, params)
+        attributes.each do |resource_params, attr_name|
+          if @required || resource_params.has_key?(attr_name)
+            validate_param!(attr_name, resource_params)
+          end
+        end
+      end
+
+      class AttributesIterator
+        include Enumerable
+
+        def initialize(validator, scope, params)
+          @attrs = validator.attrs
+          @params = scope.params(params)
+          @params = (@params.is_a?(Array) ? @params : [@params])
+        end
 
-        (params.is_a?(Array) ? params : [params]).each do |resource_params|
-          @attrs.each do |attr_name|
-            if @required || resource_params.has_key?(attr_name)
-              validate_param!(attr_name, resource_params)
+        def each
+          @params.each do |resource_params|
+            @attrs.each do |attr_name|
+              yield resource_params, attr_name
             end
           end
         end
       end
 
-    private
+      private
 
       def self.convert_to_short_name(klass)
-        ret = klass.name.gsub(/::/, '/').
-          gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
-          gsub(/([a-z\d])([A-Z])/,'\1_\2').
-          tr("-", "_").
-          downcase
+        ret = klass.name.gsub(/::/, '/')
+          .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+          .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+          .tr("-", "_")
+          .downcase
         File.basename(ret, '_validator')
       end
     end
@@ -49,7 +62,6 @@ module Grape
         @option = options
         super
       end
-
     end
 
     # We define Validator::inherited here so SingleOptionValidator
@@ -57,7 +69,7 @@ module Grape
     class Validator
       def self.inherited(klass)
         short_name = convert_to_short_name(klass)
-        Validations::register_validator(short_name, klass)
+        Validations.register_validator(short_name, klass)
       end
     end
 
@@ -74,71 +86,173 @@ module Grape
     class ParamsScope
       attr_accessor :element, :parent
 
-      def initialize(api, element, parent, &block)
-        @element = element
-        @parent = parent
-        @api = api
+      def initialize(opts, &block)
+        @element  = opts[:element]
+        @parent   = opts[:parent]
+        @api      = opts[:api]
+        @optional = opts[:optional] || false
+        @type     = opts[:type]
+        @declared_params = []
+
         instance_eval(&block)
-      end
 
-      def requires(*attrs)
-        validations = {:presence => true}
-        if attrs.last.is_a?(Hash)
-          validations.merge!(attrs.pop)
-        end
+        configure_declared_params
+      end
 
-        push_declared_params(attrs)
-        validates(attrs, validations)
+      def should_validate?(parameters)
+        return false if @optional && params(parameters).respond_to?(:all?) && params(parameters).all?(&:blank?)
+        return true if parent.nil?
+        parent.should_validate?(parameters)
       end
 
-      def optional(*attrs)
-        validations = {}
-        if attrs.last.is_a?(Hash)
-          validations.merge!(attrs.pop)
+      def requires(*attrs, &block)
+        orig_attrs = attrs.clone
+
+        opts = attrs.last.is_a?(Hash) ? attrs.pop : nil
+
+        if opts && opts[:using]
+          require_required_and_optional_fields(attrs.first, opts)
+        else
+          validate_attributes(attrs, opts, &block)
+
+          block_given? ? new_scope(orig_attrs, &block) :
+            push_declared_params(attrs)
         end
+      end
+
+      def optional(*attrs, &block)
+        orig_attrs = attrs
 
-        push_declared_params(attrs)
+        validations = {}
+        validations.merge!(attrs.pop) if attrs.last.is_a?(Hash)
+        validations[:type] ||= Array if block_given?
         validates(attrs, validations)
+
+        block_given? ? new_scope(orig_attrs, true, &block) :
+          push_declared_params(attrs)
       end
 
-      def group(element, &block)
-        ParamsScope.new(@api, element, self, &block)
+      def group(*attrs, &block)
+        requires(*attrs, &block)
       end
 
       def params(params)
         params = @parent.params(params) if @parent
-        params = params[@element] || {} if @element
+        if @element
+          if params.is_a?(Array)
+            params = params.flat_map { |el| el[@element] || {} }
+          elsif params.is_a?(Hash)
+            params = params[@element] || {}
+          else
+            params = {}
+          end
+        end
         params
       end
 
+      def use(*names)
+        named_params = @api.settings[:named_params] || {}
+        names.each do |name|
+          params_block = named_params.fetch(name) do
+            raise "Params :#{name} not found!"
+          end
+          instance_eval(&params_block)
+        end
+      end
+      alias_method :use_scope, :use
+      alias_method :includes, :use
+
       def full_name(name)
         return "#{@parent.full_name(@element)}[#{name}]" if @parent
         name.to_s
       end
 
-    private
+      protected
+
+      def push_declared_params(attrs)
+        @declared_params.concat attrs
+      end
+
+      private
+
+      def require_required_and_optional_fields(context, opts)
+        if context == :all
+          optional_fields = Array(opts[:except])
+          required_fields = opts[:using].keys - optional_fields
+        else # context == :none
+          required_fields = Array(opts[:except])
+          optional_fields = opts[:using].keys - required_fields
+        end
+        required_fields.each do |field|
+          requires(field, opts[:using][field])
+        end
+        optional_fields.each do |field|
+          optional(field, opts[:using][field])
+        end
+      end
+
+      def validate_attributes(attrs, opts, &block)
+        validations = { presence: true }
+        validations.merge!(opts) if opts
+        validations[:type] ||= Array if block
+        validates(attrs, validations)
+      end
+
+      def new_scope(attrs, optional = false, &block)
+        opts = attrs[1] || { type: Array }
+        raise ArgumentError unless opts.keys.to_set.subset? [:type].to_set
+        ParamsScope.new(api: @api, element: attrs.first, parent: self, optional: optional, type: opts[:type], &block)
+      end
+
+      # Pushes declared params to parent or settings
+      def configure_declared_params
+        if @parent
+          @parent.push_declared_params [element => @declared_params]
+        else
+          @api.settings.peek[:declared_params] ||= []
+          @api.settings[:declared_params].concat @declared_params
+        end
+      end
+
       def validates(attrs, validations)
-        doc_attrs = { :required => validations.keys.include?(:presence) }
+        doc_attrs = { required: validations.keys.include?(:presence) }
 
         # special case (type = coerce)
-        if validations[:type]
-          validations[:coerce] = validations.delete(:type)
-        end
+        validations[:coerce] = validations.delete(:type) if validations.key?(:type)
+
+        coerce_type = validations[:coerce]
+        doc_attrs[:type] = coerce_type.to_s if coerce_type
+
+        desc = validations.delete(:desc)
+        doc_attrs[:desc] = desc if desc
+
+        default = validations[:default]
+        doc_attrs[:default] = default if default
+
+        values = validations[:values]
+        doc_attrs[:values] = values if values
 
-        if coerce_type = validations[:coerce]
-          doc_attrs[:type] = coerce_type.to_s
+        values = (values.is_a?(Proc) ? values.call : values)
+
+        # default value should be present in values array, if both exist
+        if default && values && !values.include?(default)
+          raise Grape::Exceptions::IncompatibleOptionValues.new(:default, default, :values, values)
         end
 
-        if desc = validations.delete(:desc)
-          doc_attrs[:desc] = desc
+        # type should be compatible with values array, if both exist
+        if coerce_type && values && values.any? { |v| !v.kind_of?(coerce_type) }
+          raise Grape::Exceptions::IncompatibleOptionValues.new(:type, coerce_type, :values, values)
         end
 
-        full_attrs = attrs.collect{ |name| { :name => name, :full_name => full_name(name)} }
+        doc_attrs[:documentation] = validations.delete(:documentation) if validations.key?(:documentation)
+
+        full_attrs = attrs.collect { |name| { name: name, full_name: full_name(name) } }
         @api.document_attribute(full_attrs, doc_attrs)
 
         # Validate for presence before any other validators
         if validations.has_key?(:presence) && validations[:presence]
           validate('presence', validations[:presence], attrs, doc_attrs)
+          validations.delete(:presence)
         end
 
         # Before we run the rest of the validators, lets handle
@@ -155,7 +269,7 @@ module Grape
       end
 
       def validate(type, options, attrs, doc_attrs)
-        validator_class = Validations::validators[type.to_s]
+        validator_class = Validations.validators[type.to_s]
 
         if validator_class
           (@api.settings.peek[:validations] ||= []) << validator_class.new(attrs, options, doc_attrs[:required], self)
@@ -163,11 +277,6 @@ module Grape
           raise Grape::Exceptions::UnknownValidator.new(type)
         end
       end
-
-      def push_declared_params(attrs)
-        @api.settings.peek[:declared_params] ||= []
-        @api.settings[:declared_params] += attrs
-      end
     end
 
     # This module is mixed into the API Class.
@@ -178,7 +287,7 @@ module Grape
       end
 
       def params(&block)
-        ParamsScope.new(self, nil, nil, &block)
+        ParamsScope.new(api: self, type: Hash, &block)
       end
 
       def document_attribute(names, opts)
@@ -189,9 +298,7 @@ module Grape
           @last_description[:params][name[:full_name].to_s].merge!(opts)
         end
       end
-
     end
-
   end
 end
 

data/lib/grape/version.rb

@@ -1,3 +1,3 @@
 module Grape
-  VERSION = '0.3.0'
+  VERSION = '0.7.0'
 end