grape 1.8.0 → 3.3.5

data/lib/grape/validations/types/build_coercer.rb

@@ -1,94 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'array_coercer'
-require_relative 'set_coercer'
-require_relative 'primitive_coercer'
-
-module Grape
-  module Validations
-    module Types
-      # Chooses the best coercer for the given type. For example, if the type
-      # is Integer, it will return a coercer which will be able to coerce a value
-      # to the integer.
-      #
-      # There are a few very special coercers which might be returned.
-      #
-      # +Grape::Types::MultipleTypeCoercer+ is a coercer which is returned when
-      # the given type implies values in an array with different types.
-      # For example, +[Integer, String]+ allows integer and string values in
-      # an array.
-      #
-      # +Grape::Types::CustomTypeCoercer+ is a coercer which is returned when
-      # a method is specified by a user with +coerce_with+ option or the user
-      # specifies a custom type which implements requirments of
-      # +Grape::Types::CustomTypeCoercer+.
-      #
-      # +Grape::Types::CustomTypeCollectionCoercer+ is a very similar to the
-      # previous one, but it expects an array or set of values having a custom
-      # type implemented by the user.
-      #
-      # There is also a group of custom types implemented by Grape, check
-      # +Grape::Validations::Types::SPECIAL+ to get the full list.
-      #
-      # @param type [Class] the type to which input strings
-      #   should be coerced
-      # @param method [Class,#call] the coercion method to use
-      # @return [Object] object to be used
-      #   for coercion and type validation
-      def self.build_coercer(type, method: nil, strict: false)
-        cache_instance(type, method, strict) do
-          create_coercer_instance(type, method, strict)
-        end
-      end
-
-      def self.create_coercer_instance(type, method, strict)
-        # Maps a custom type provided by Grape, it doesn't map types wrapped by collections!!!
-        type = Types.map_special(type)
-
-        # Use a special coercer for multiply-typed parameters.
-        if Types.multiple?(type)
-          MultipleTypeCoercer.new(type, method)
-
-        # Use a special coercer for custom types and coercion methods.
-        elsif method || Types.custom?(type)
-          CustomTypeCoercer.new(type, method)
-
-        # Special coercer for collections of types that implement a parse method.
-        # CustomTypeCoercer (above) already handles such types when an explicit coercion
-        # method is supplied.
-        elsif Types.collection_of_custom?(type)
-          Types::CustomTypeCollectionCoercer.new(
-            Types.map_special(type.first), type.is_a?(Set)
-          )
-        else
-          DryTypeCoercer.coercer_instance_for(type, strict)
-        end
-      end
-
-      def self.cache_instance(type, method, strict, &_block)
-        key = cache_key(type, method, strict)
-
-        return @__cache[key] if @__cache.key?(key)
-
-        instance = yield
-
-        @__cache_write_lock.synchronize do
-          @__cache[key] = instance
-        end
-
-        instance
-      end
-
-      def self.cache_key(type, method, strict)
-        [type, method, strict].each_with_object(+'_') do |val, memo|
-          next if val.nil?
-
-          memo << '_' << val.to_s
-        end
-      end
-
-      instance_variable_set(:@__cache,            {})
-      instance_variable_set(:@__cache_write_lock, Mutex.new)
-    end
-  end
-end

data/lib/grape/validations/validator_factory.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-module Grape
-  module Validations
-    class ValidatorFactory
-      def self.create_validator(**options)
-        options[:validator_class].new(options[:attributes],
-                                      options[:options],
-                                      options[:required],
-                                      options[:params_scope],
-                                      **options[:opts])
-      end
-    end
-  end
-end

data/spec/grape/api/custom_validations_spec.rb

@@ -1,213 +0,0 @@
-# frozen_string_literal: true
-
-require 'shared/deprecated_class_examples'
-
-describe Grape::Validations do
-  describe 'Grape::Validations::Base' do
-    let(:deprecated_class) do
-      Class.new(Grape::Validations::Base)
-    end
-
-    it_behaves_like 'deprecated class'
-  end
-
-  describe 'using a custom length validator' do
-    subject do
-      Class.new(Grape::API) do
-        params do
-          requires :text, default_length: 140
-        end
-        get do
-          'bacon'
-        end
-      end
-    end
-
-    let(:default_length_validator) do
-      Class.new(Grape::Validations::Validators::Base) do
-        def validate_param!(attr_name, params)
-          @option = params[:max].to_i if params.key?(:max)
-          return if params[attr_name].length <= @option
-
-          raise Grape::Exceptions::Validation.new(params: [@scope.full_name(attr_name)], message: "must be at the most #{@option} characters long")
-        end
-      end
-    end
-    let(:app) { Rack::Builder.new(subject) }
-
-    before do
-      described_class.register_validator('default_length', default_length_validator)
-    end
-
-    after do
-      described_class.deregister_validator('default_length')
-    end
-
-    it 'under 140 characters' do
-      get '/', text: 'abc'
-      expect(last_response.status).to eq 200
-      expect(last_response.body).to eq 'bacon'
-    end
-
-    it 'over 140 characters' do
-      get '/', text: 'a' * 141
-      expect(last_response.status).to eq 400
-      expect(last_response.body).to eq 'text must be at the most 140 characters long'
-    end
-
-    it 'specified in the query string' do
-      get '/', text: 'a' * 141, max: 141
-      expect(last_response.status).to eq 200
-      expect(last_response.body).to eq 'bacon'
-    end
-  end
-
-  describe 'using a custom body-only validator' do
-    subject do
-      Class.new(Grape::API) do
-        params do
-          requires :text, in_body: true
-        end
-        get do
-          'bacon'
-        end
-      end
-    end
-
-    let(:in_body_validator) do
-      Class.new(Grape::Validations::Validators::PresenceValidator) do
-        def validate(request)
-          validate!(request.env['api.request.body'])
-        end
-      end
-    end
-    let(:app) { Rack::Builder.new(subject) }
-
-    before do
-      described_class.register_validator('in_body', in_body_validator)
-    end
-
-    after do
-      described_class.deregister_validator('in_body')
-    end
-
-    it 'allows field in body' do
-      get '/', text: 'abc'
-      expect(last_response.status).to eq 200
-      expect(last_response.body).to eq 'bacon'
-    end
-
-    it 'ignores field in query' do
-      get '/', nil, text: 'abc'
-      expect(last_response.status).to eq 400
-      expect(last_response.body).to eq 'text is missing'
-    end
-  end
-
-  describe 'using a custom validator with message_key' do
-    subject do
-      Class.new(Grape::API) do
-        params do
-          requires :text, with_message_key: true
-        end
-        get do
-          'bacon'
-        end
-      end
-    end
-
-    let(:message_key_validator) do
-      Class.new(Grape::Validations::Validators::PresenceValidator) do
-        def validate_param!(attr_name, _params)
-          raise Grape::Exceptions::Validation.new(params: [@scope.full_name(attr_name)], message: :presence)
-        end
-      end
-    end
-    let(:app) { Rack::Builder.new(subject) }
-
-    before do
-      described_class.register_validator('with_message_key', message_key_validator)
-    end
-
-    after do
-      described_class.deregister_validator('with_message_key')
-    end
-
-    it 'fails with message' do
-      get '/', text: 'foobar'
-      expect(last_response.status).to eq 400
-      expect(last_response.body).to eq 'text is missing'
-    end
-  end
-
-  describe 'using a custom request/param validator' do
-    subject do
-      Class.new(Grape::API) do
-        params do
-          optional :admin_field, type: String, admin: true
-          optional :non_admin_field, type: String
-          optional :admin_false_field, type: String, admin: false
-        end
-        get do
-          'bacon'
-        end
-      end
-    end
-
-    let(:admin_validator) do
-      Class.new(Grape::Validations::Validators::Base) do
-        def validate(request)
-          # return if the param we are checking was not in request
-          # @attrs is a list containing the attribute we are currently validating
-          return unless request.params.key? @attrs.first
-          # check if admin flag is set to true
-          return unless @option
-          # check if user is admin or not
-          # as an example get a token from request and check if it's admin or not
-          raise Grape::Exceptions::Validation.new(params: @attrs, message: 'Can not set Admin only field.') unless request.headers['X-Access-Token'] == 'admin'
-        end
-      end
-    end
-    let(:app) { Rack::Builder.new(subject) }
-
-    before do
-      described_class.register_validator('admin', admin_validator)
-    end
-
-    after do
-      described_class.deregister_validator('admin')
-    end
-
-    it 'fail when non-admin user sets an admin field' do
-      get '/', admin_field: 'tester', non_admin_field: 'toaster'
-      expect(last_response.status).to eq 400
-      expect(last_response.body).to include 'Can not set Admin only field.'
-    end
-
-    it 'does not fail when we send non-admin fields only' do
-      get '/', non_admin_field: 'toaster'
-      expect(last_response.status).to eq 200
-      expect(last_response.body).to eq 'bacon'
-    end
-
-    it 'does not fail when we send non-admin and admin=false fields only' do
-      get '/', non_admin_field: 'toaster', admin_false_field: 'test'
-      expect(last_response.status).to eq 200
-      expect(last_response.body).to eq 'bacon'
-    end
-
-    it 'does not fail when we send admin fields and we are admin' do
-      header 'X-Access-Token', 'admin'
-      get '/', admin_field: 'tester', non_admin_field: 'toaster', admin_false_field: 'test'
-      expect(last_response.status).to eq 200
-      expect(last_response.body).to eq 'bacon'
-    end
-
-    it 'fails when we send admin fields and we are not admin' do
-      header 'X-Access-Token', 'user'
-      get '/', admin_field: 'tester', non_admin_field: 'toaster', admin_false_field: 'test'
-      expect(last_response.status).to eq 400
-      expect(last_response.body).to include 'Can not set Admin only field.'
-    end
-  end
-end

data/spec/grape/api/deeply_included_options_spec.rb

@@ -1,56 +0,0 @@
-# frozen_string_literal: true
-
-module DeeplyIncludedOptionsSpec
-  module Defaults
-    extend ActiveSupport::Concern
-    included do
-      format :json
-    end
-  end
-
-  module Admin
-    module Defaults
-      extend ActiveSupport::Concern
-      include DeeplyIncludedOptionsSpec::Defaults
-    end
-
-    class Users < Grape::API
-      include DeeplyIncludedOptionsSpec::Admin::Defaults
-
-      resource :users do
-        get do
-          status 200
-        end
-      end
-    end
-  end
-
-  class Main < Grape::API
-    mount DeeplyIncludedOptionsSpec::Admin::Users
-  end
-end
-
-describe Grape::API do
-  subject { DeeplyIncludedOptionsSpec::Main }
-
-  def app
-    subject
-  end
-
-  it 'works for unspecified format' do
-    get '/users'
-    expect(last_response.status).to be 200
-    expect(last_response.content_type).to eql 'application/json'
-  end
-
-  it 'works for specified format' do
-    get '/users.json'
-    expect(last_response.status).to be 200
-    expect(last_response.content_type).to eql 'application/json'
-  end
-
-  it "doesn't work for format different than specified" do
-    get '/users.txt'
-    expect(last_response.status).to be 404
-  end
-end

data/spec/grape/api/defines_boolean_in_params_spec.rb

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-describe Grape::API::Instance do
-  describe 'boolean constant' do
-    module DefinesBooleanInstanceSpec
-      class API < Grape::API
-        params do
-          requires :message, type: Boolean
-        end
-        post :echo do
-          { class: params[:message].class.name, value: params[:message] }
-        end
-      end
-    end
-
-    def app
-      DefinesBooleanInstanceSpec::API
-    end
-
-    let(:expected_body) do
-      { class: 'TrueClass', value: true }.to_s
-    end
-
-    it 'sets Boolean as a type' do
-      post '/echo?message=true'
-      expect(last_response.status).to eq(201)
-      expect(last_response.body).to eq expected_body
-    end
-
-    context 'Params endpoint type' do
-      subject { DefinesBooleanInstanceSpec::API.new.router.map['POST'].first.options[:params]['message'][:type] }
-
-      it 'params type is a boolean' do
-        expect(subject).to eq 'Grape::API::Boolean'
-      end
-    end
-  end
-end

data/spec/grape/api/documentation_spec.rb

@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe Grape::API do
-  subject { Class.new(described_class) }
-
-  let(:app) { subject }
-
-  context 'an endpoint with documentation' do
-    it 'documents parameters' do
-      subject.params do
-        requires 'price', type: Float, desc: 'Sales price'
-      end
-      subject.get '/'
-
-      expect(subject.routes.first.params['price']).to eq(required: true,
-                                                         type: 'Float',
-                                                         desc: 'Sales price')
-    end
-
-    it 'allows documentation with a hash' do
-      documentation = { example: 'Joe' }
-
-      subject.params do
-        requires 'first_name', documentation: documentation
-      end
-      subject.get '/'
-
-      expect(subject.routes.first.params['first_name'][:documentation]).to eq(documentation)
-    end
-  end
-
-  context 'an endpoint without documentation' do
-    before do
-      subject.do_not_document!
-
-      subject.params do
-        requires :city, type: String, desc: 'Should be ignored'
-        optional :postal_code, type: Integer
-      end
-      subject.post '/' do
-        declared(params).to_json
-      end
-    end
-
-    it 'does not document parameters for the endpoint' do
-      expect(subject.routes.first.params).to eq({})
-    end
-
-    it 'still declares params internally' do
-      data = { city: 'Berlin', postal_code: 10_115 }
-
-      post '/', data
-
-      expect(last_response.body).to eq(data.to_json)
-    end
-  end
-end

data/spec/grape/api/inherited_helpers_spec.rb

@@ -1,114 +0,0 @@
-# frozen_string_literal: true
-
-describe Grape::API::Helpers do
-  let(:user) { 'Miguel Caneo' }
-  let(:id)   { '42' }
-
-  module InheritedHelpersSpec
-    class SuperClass < Grape::API
-      helpers do
-        params(:superclass_params) { requires :id, type: String }
-
-        def current_user
-          params[:user]
-        end
-      end
-    end
-
-    class OverriddenSubClass < SuperClass
-      params { use :superclass_params }
-
-      helpers do
-        def current_user
-          "#{params[:user]} with id"
-        end
-      end
-
-      get 'resource' do
-        "#{current_user}: #{params['id']}"
-      end
-    end
-
-    class SubClass < SuperClass
-      params { use :superclass_params }
-
-      get 'resource' do
-        "#{current_user}: #{params['id']}"
-      end
-    end
-
-    class Example < SubClass
-      params { use :superclass_params }
-
-      get 'resource' do
-        "#{current_user}: #{params['id']}"
-      end
-    end
-  end
-
-  context 'non overriding subclass' do
-    subject { InheritedHelpersSpec::SubClass }
-
-    def app
-      subject
-    end
-
-    context 'given expected params' do
-      it 'inherits helpers from a superclass' do
-        get '/resource', id: id, user: user
-        expect(last_response.body).to eq("#{user}: #{id}")
-      end
-    end
-
-    context 'with lack of expected params' do
-      it 'returns missing error' do
-        get '/resource'
-        expect(last_response.body).to eq('id is missing')
-      end
-    end
-  end
-
-  context 'overriding subclass' do
-    subject { InheritedHelpersSpec::OverriddenSubClass }
-
-    def app
-      subject
-    end
-
-    context 'given expected params' do
-      it 'overrides helpers from a superclass' do
-        get '/resource', id: id, user: user
-        expect(last_response.body).to eq("#{user} with id: #{id}")
-      end
-    end
-
-    context 'with lack of expected params' do
-      it 'returns missing error' do
-        get '/resource'
-        expect(last_response.body).to eq('id is missing')
-      end
-    end
-  end
-
-  context 'example subclass' do
-    subject { InheritedHelpersSpec::Example }
-
-    def app
-      subject
-    end
-
-    context 'given expected params' do
-      it 'inherits helpers from a superclass' do
-        get '/resource', id: id, user: user
-        expect(last_response.body).to eq("#{user}: #{id}")
-      end
-    end
-
-    context 'with lack of expected params' do
-      it 'returns missing error' do
-        get '/resource'
-        expect(last_response.body).to eq('id is missing')
-      end
-    end
-  end
-end

data/spec/grape/api/instance_spec.rb

@@ -1,103 +0,0 @@
-# frozen_string_literal: true
-
-require 'shared/versioning_examples'
-
-describe Grape::API::Instance do
-  subject(:an_instance) do
-    Class.new(Grape::API::Instance) do
-      namespace :some_namespace do
-        get 'some_endpoint' do
-          'success'
-        end
-      end
-    end
-  end
-
-  let(:root_api) do
-    to_mount = an_instance
-    Class.new(Grape::API) do
-      mount to_mount
-    end
-  end
-
-  def app
-    root_api
-  end
-
-  context 'when an instance is mounted on the root' do
-    it 'can call the instance endpoint' do
-      get '/some_namespace/some_endpoint'
-      expect(last_response.body).to eq 'success'
-    end
-  end
-
-  context 'when an instance is the root' do
-    let(:root_api) do
-      to_mount = an_instance
-      Class.new(Grape::API::Instance) do
-        mount to_mount
-      end
-    end
-
-    it 'can call the instance endpoint' do
-      get '/some_namespace/some_endpoint'
-      expect(last_response.body).to eq 'success'
-    end
-  end
-
-  context 'top level setting' do
-    it 'does not inherit settings from the superclass (Grape::API::Instance)' do
-      expect(an_instance.top_level_setting.parent).to be_nil
-    end
-  end
-
-  context 'with multiple moutes' do
-    let(:first) do
-      Class.new(Grape::API::Instance) do
-        namespace(:some_namespace) do
-          route :any, '*path' do
-            error!('Not found! (1)', 404)
-          end
-        end
-      end
-    end
-    let(:second) do
-      Class.new(Grape::API::Instance) do
-        namespace(:another_namespace) do
-          route :any, '*path' do
-            error!('Not found! (2)', 404)
-          end
-        end
-      end
-    end
-    let(:root_api) do
-      first_instance = first
-      second_instance = second
-      Class.new(Grape::API) do
-        mount first_instance
-        mount first_instance
-        mount second_instance
-      end
-    end
-
-    it 'does not raise a FrozenError on first instance' do
-      expect { patch '/some_namespace/anything' }.not_to \
-        raise_error
-    end
-
-    it 'responds the correct body at the first instance' do
-      patch '/some_namespace/anything'
-      expect(last_response.body).to eq 'Not found! (1)'
-    end
-
-    it 'does not raise a FrozenError on second instance' do
-      expect { get '/another_namespace/other' }.not_to \
-        raise_error
-    end
-
-    it 'responds the correct body at the second instance' do
-      get '/another_namespace/foobar'
-      expect(last_response.body).to eq 'Not found! (2)'
-    end
-  end
-end