grape 0.9.0 → 0.10.0

data/lib/grape/validations/at_least_one_of.rb

@@ -1,25 +0,0 @@
-module Grape
-  module Validations
-    class AtLeastOneOfValidator < Validator
-      attr_reader :params
-
-      def validate!(params)
-        @params = params
-        if no_exclusive_params_are_present
-          raise Grape::Exceptions::Validation, params: attrs.map(&:to_s), message_key: :at_least_one
-        end
-        params
-      end
-
-      private
-
-      def no_exclusive_params_are_present
-        keys_in_common.length == 0
-      end
-
-      def keys_in_common
-        (attrs.map(&:to_s) & params.stringify_keys.keys).map(&:to_s)
-      end
-    end
-  end
-end

data/lib/grape/validations/exactly_one_of.rb

@@ -1,26 +0,0 @@
-module Grape
-  module Validations
-    require 'grape/validations/mutual_exclusion'
-    class ExactlyOneOfValidator < MutualExclusionValidator
-      attr_reader :params
-
-      def validate!(params)
-        super
-        if none_of_restricted_params_is_present
-          raise Grape::Exceptions::Validation, params: all_keys, message_key: :exactly_one
-        end
-        params
-      end
-
-      private
-
-      def none_of_restricted_params_is_present
-        keys_in_common.length < 1
-      end
-
-      def all_keys
-        attrs.map(&:to_s)
-      end
-    end
-  end
-end

data/lib/grape/validations/mutual_exclusion.rb

@@ -1,25 +0,0 @@
-module Grape
-  module Validations
-    class MutualExclusionValidator < Validator
-      attr_reader :params
-
-      def validate!(params)
-        @params = params
-        if two_or_more_exclusive_params_are_present
-          raise Grape::Exceptions::Validation, params: keys_in_common, message_key: :mutual_exclusion
-        end
-        params
-      end
-
-      private
-
-      def two_or_more_exclusive_params_are_present
-        keys_in_common.length > 1
-      end
-
-      def keys_in_common
-        (attrs.map(&:to_s) & params.stringify_keys.keys).map(&:to_s)
-      end
-    end
-  end
-end

data/lib/grape/validations/regexp.rb

@@ -1,12 +0,0 @@
-module Grape
-  module Validations
-    class RegexpValidator < SingleOptionValidator
-      def validate_param!(attr_name, params)
-        if params.key?(attr_name) &&
-          (params[attr_name].nil? || !(params[attr_name].to_s =~ @option))
-          raise Grape::Exceptions::Validation, params: [@scope.full_name(attr_name)], message_key: :regexp
-        end
-      end
-    end
-  end
-end

data/lib/grape/validations/values.rb

@@ -1,23 +0,0 @@
-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_for_root_scope?) && !(@values.is_a?(Proc) ? @values.call : @values).include?(params[attr_name])
-          raise Grape::Exceptions::Validation, params: [@scope.full_name(attr_name)], message_key: :values
-        end
-      end
-
-      private
-
-      def required_for_root_scope?
-        @required && @scope.root?
-      end
-    end
-  end
-end

data/spec/grape/util/hash_stack_spec.rb

@@ -1,132 +0,0 @@
-require 'spec_helper'
-
-describe Grape::Util::HashStack do
-
-  describe '#get' do
-    it 'finds the first available key' do
-      subject[:abc] = 123
-      subject.push(abc: 345)
-      expect(subject.get(:abc)).to eq(345)
-    end
-
-    it 'is nil if the key has not been set' do
-      expect(subject[:abc]).to be_nil
-    end
-  end
-
-  describe '#set' do
-    it 'sets a value on the highest frame' do
-      subject.push
-      subject.set(:abc, 123)
-      expect(subject.stack.last[:abc]).to eq(123)
-    end
-  end
-
-  describe '#imbue' do
-    it 'pushes a new value onto the end of an array' do
-      subject[:abc] = []
-      subject.imbue :abc, [123]
-      subject.imbue :abc, [456]
-      expect(subject[:abc]).to eq([123, 456])
-    end
-
-    it 'merges a hash that is passed' do
-      subject[:abc] = { foo: 'bar' }
-      subject.imbue :abc, baz: 'wich'
-      expect(subject[:abc]).to eq(foo: 'bar', baz: 'wich')
-    end
-
-    it 'sets the value if not a hash or array' do
-      subject.imbue :abc, 123
-      expect(subject[:abc]).to eq(123)
-    end
-
-    it 'is able to imbue an array without explicit setting' do
-      subject.imbue :arr, [1]
-      subject.imbue :arr, [2]
-      expect(subject[:arr]).to eq([1, 2])
-    end
-
-    it 'is able to imbue a hash without explicit setting' do
-      subject.imbue :hash, foo: 'bar'
-      subject.imbue :hash, baz: 'wich'
-      expect(subject[:hash]).to eq(foo: 'bar', baz: 'wich')
-    end
-  end
-
-  describe '#push' do
-    it 'returns a HashStack' do
-      expect(subject.push(Grape::Util::HashStack.new)).to be_kind_of(Grape::Util::HashStack)
-    end
-
-    it 'places the passed value on the top of the stack' do
-      subject.push(abc: 123)
-      expect(subject.stack).to eq([{}, { abc: 123 }])
-    end
-
-    it 'pushes an empty hash by default' do
-      subject[:abc] = 123
-      subject.push
-      expect(subject.stack).to eq([{ abc: 123 }, {}])
-    end
-  end
-
-  describe '#pop' do
-    it 'removes and return the top frame' do
-      subject.push(abc: 123)
-      expect(subject.pop).to eq(abc: 123)
-      expect(subject.stack.size).to eq(1)
-    end
-  end
-
-  describe '#peek' do
-    it 'returns the top frame without removing it' do
-      subject.push(abc: 123)
-      expect(subject.peek).to eq(abc: 123)
-      expect(subject.stack.size).to eq(2)
-    end
-  end
-
-  describe '#prepend' do
-    it 'returns a HashStack' do
-      expect(subject.prepend(Grape::Util::HashStack.new)).to be_kind_of(Grape::Util::HashStack)
-    end
-
-    it "prepends a HashStack's stack onto its own stack" do
-      other = Grape::Util::HashStack.new.push(abc: 123)
-      expect(subject.prepend(other).stack).to eq([{}, { abc: 123 }, {}])
-    end
-  end
-
-  describe '#concat' do
-    it 'returns a HashStack' do
-      expect(subject.concat(Grape::Util::HashStack.new)).to be_kind_of(Grape::Util::HashStack)
-    end
-
-    it "appends a HashStack's stack onto its own stack" do
-      other = Grape::Util::HashStack.new.push(abc: 123)
-      expect(subject.concat(other).stack).to eq([{}, {}, { abc: 123 }])
-    end
-  end
-
-  describe '#update' do
-    it 'merges! into the top frame' do
-      subject.update(abc: 123)
-      expect(subject.stack).to eq([{ abc: 123 }])
-    end
-
-    it 'returns a HashStack' do
-      expect(subject.update(abc: 123)).to be_kind_of(Grape::Util::HashStack)
-    end
-  end
-
-  describe '#clone' do
-    it 'performs a deep copy' do
-      subject[:abc] = 123
-      subject.push def: 234
-      clone = subject.clone
-      clone[:def] = 345
-      expect(subject[:def]).to eq(234)
-    end
-  end
-end