compel 0.4.0 → 0.4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 032ba6894d54a63ee956025716cb973156d601b0
-  data.tar.gz: 0121184a327f472d7750180db68411253f91d465
+  metadata.gz: 97cfa78c4892af6b318eb14948f7b0defccc5863
+  data.tar.gz: d30bc04383159e49098a7a861995ee61f1d1e7f0
 SHA512:
-  metadata.gz: 4fb359e62420fc5a8b780297bfc05a9ffcc986034d362e4cace62626a4f8e67c0e75a38013335f8fe1eb48c93a560ba2bbc41b9ecdfd49eeaa591443fcfb1f71
-  data.tar.gz: f933cdda27071b04278ff0812f91c7956a4a92e478c08c6912cef70878de9bddb88860e5b7f074bedcdcd3620c002c919c4b13a69ae9ce71abe2f58371d0480e
+  metadata.gz: 90ee036e1d29802696e42c90c2c2a8b179de2ccc609b71d597e75fce23389273ebbf39fed245e1dd6811ece2f7b7eb74e2f52faa3bee2abb51025e0640dfe988
+  data.tar.gz: 8848f0337a8c43b8b012e70b6c117c7352e2c5418dc7c8891063e93d6468825e4b323ccb367e9873960e7b188af4454dfde1b129978e04f18015877d3dd4e012

data/.travis.yml

@@ -1,3 +1,4 @@
 language: ruby
 rvm:
+  - 1.9.3
   - 2.2.3

data/LICENSE

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2015 Joaquim Adráz
+Copyright (c) 2016 Joaquim Adráz
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -217,6 +217,27 @@ Method  | Behaviour
 `#valid?` | `true` or `false`
 `#raise?` | raises a `Compel::InvalidObjectError` if invalid, otherwise returns `#value`
 
+#### Custom Options
+
+`Custom error message`
+
+Examples:
+```ruby
+schema = Compel.string.required(message: 'this is really required')
+
+result = schema.validate(nil)
+
+p result.errors
+=> ["this is really required"]
+
+schema = Compel.string.is('Hello', message: 'give me an Hello!')
+
+result = schema.validate(nil)
+
+p result.errors
+=> ["give me an Hello!"]
+```
+
 ==========================
 
 ### Sinatra Integration

data/lib/compel/builder/array.rb

@@ -7,18 +7,16 @@ module Compel
         super(Coercion::Array)
       end
 
-      def items(schema)
+      def items(schema, options = {})
         if !schema.is_a?(Schema)
           raise Compel::TypeError, '#items must be a valid Schema'
         end
 
-        options[:items] = schema
-        self
+        build_option :items, schema, options
       end
 
       def is(value)
-        options[:is] = Coercion.coerce!(value, Coercion::Array)
-        self
+        build_option :is, Coercion.coerce!(value, Coercion::Array)
       end
 
     end

data/lib/compel/builder/boolean.rb

@@ -7,11 +7,10 @@ module Compel
         super(Coercion::Boolean)
       end
 
-      def is(value)
+      def is(value, options = {})
         Coercion.coerce!(value, Coercion::Boolean)
-        options[:is] = value
 
-        self
+        build_option :is, value, options
       end
 
     end

data/lib/compel/builder/common.rb

@@ -3,34 +3,28 @@ module Compel
 
     module Common
 
-      def is(value)
-        options[:is] = Coercion.coerce!(value, self.type)
-        self
+      def is(value, options = {})
+        build_option :is, Coercion.coerce!(value, self.type), options
       end
 
-      def required
-        options[:required] = true
-        self
+      def required(options = {})
+        build_option :required, true, options
       end
 
-      def default(value)
-        options[:default] = Coercion.coerce!(value, self.type)
-        self
+      def default(value, options = {})
+        build_option :default, Coercion.coerce!(value, self.type), options
       end
 
-      def length(value)
-        options[:length] = Coercion.coerce!(value, Coercion::Integer)
-        self
+      def length(value, options = {})
+        build_option :length, Coercion.coerce!(value, Coercion::Integer), options
       end
 
-      def min_length(value)
-        options[:min_length] = Coercion.coerce!(value, Coercion::Integer)
-        self
+      def min_length(value, options = {})
+        build_option :min_length, Coercion.coerce!(value, Coercion::Integer), options
       end
 
-      def max_length(value)
-        options[:max_length] = Coercion.coerce!(value, Coercion::Integer)
-        self
+      def max_length(value, options = {})
+        build_option :max_length, Coercion.coerce!(value, Coercion::Integer), options
       end
 
     end

data/lib/compel/builder/common_value.rb

@@ -3,24 +3,20 @@ module Compel
 
     module CommonValue
 
-      def in(value)
-        options[:in] = coerce_values_ary!(value, :in)
-        self
+      def in(value, options = {})
+        build_option :in, coerce_values_ary!(value, :in), options
       end
 
-      def range(value)
-        options[:range] = coerce_values_ary!(value, :range)
-        self
+      def range(value, options = {})
+        build_option :range, coerce_values_ary!(value, :range), options
       end
 
-      def min(value)
-        options[:min] = coerce_value!(value, :min)
-        self
+      def min(value, options = {})
+        build_option :min, coerce_value!(value, :min), options
       end
 
-      def max(value)
-        options[:max] = coerce_value!(value, :max)
-        self
+      def max(value, options = {})
+        build_option :max, coerce_value!(value, :max), options
       end
 
       def coerce_values_ary!(values, method)

data/lib/compel/builder/date.rb

@@ -9,14 +9,12 @@ module Compel
         super(Coercion::Date)
       end
 
-      def format(value)
-        options[:format] = value
-        self
+      def format(value, options = {})
+        build_option :format, value, options
       end
 
-      def iso8601
-        options[:format] = '%Y-%m-%d'
-        self
+      def iso8601(options = {})
+        build_option :format, '%Y-%m-%d', options
       end
 
     end

data/lib/compel/builder/datetime.rb

@@ -9,14 +9,12 @@ module Compel
         super(Coercion::DateTime)
       end
 
-      def format(value)
-        options[:format] = value
-        self
+      def format(value, options = {})
+        build_option :format, value, options
       end
 
-      def iso8601
-        options[:format] = '%FT%T'
-        self
+      def iso8601(options = {})
+        build_option :format, '%FT%T', options
       end
 
     end

data/lib/compel/builder/hash.rb

@@ -6,12 +6,11 @@ module Compel
       def initialize
         super(Coercion::Hash)
 
-        options[:keys] = {}
+        options[:keys] = { value: {} }
       end
 
-      def keys(object)
-        options[:keys] = coerce_keys_schemas(object)
-        self
+      def keys(object, options = {})
+        build_option :keys, coerce_keys_schemas(object), options
       end
 
       private

data/lib/compel/builder/schema.rb

@@ -8,35 +8,35 @@ module Compel
       attr_reader :type,
                   :options
 
+      def self.human_name
+        "#{self.name.split('::')[1..-1].join('::')}"
+      end
+
       def initialize(type)
         @type = type
         @options = default_options
       end
 
       def required?
-        options[:required]
+        options[:required][:value]
       end
 
       def default_value
-        options[:default]
+        options[:default][:value] if options[:default]
       end
 
       def validate(object)
         Contract.new(object, self).validate
       end
 
-      class << self
-
-        def human_name
-          "#{self.name.split('::')[1..-1].join('::')}"
-        end
+      def build_option(name, value, extra_options = {})
+        options[name] = { value: value }.merge(extra_options)
 
+        self
       end
 
-      protected
-
       def default_options
-        { required: false }
+        { required: { value: false } }
       end
 
     end

data/lib/compel/builder/string.rb

@@ -17,19 +17,16 @@ module Compel
         super(Coercion::String)
       end
 
-      def format(regex)
-        options[:format] = Coercion.coerce!(regex, Coercion::Regexp)
-        self
+      def format(regex, options = {})
+        build_option :format, Coercion.coerce!(regex, Coercion::Regexp), options
       end
 
-      def url
-        options[:format] = URL_REGEX
-        self
+      def url(options = {})
+        build_option :format, URL_REGEX, options
       end
 
-      def email
-        options[:format] = EMAIL_REGEX
-        self
+      def email(options = {})
+        build_option :format, EMAIL_REGEX, options
       end
 
     end

data/lib/compel/builder/time.rb

@@ -9,14 +9,12 @@ module Compel
         super(Coercion::Time)
       end
 
-      def format(value)
-        options[:format] = value
-        self
+      def format(value, options = {})
+        build_option :format, value, options
       end
 
-      def iso8601
-        options[:format] = '%FT%T'
-        self
+      def iso8601(options = {})
+        build_option :format, '%FT%T', options
       end
 
     end

data/lib/compel/coercion/types/date.rb

@@ -8,7 +8,7 @@ module Compel
       end
 
       def default_format
-         '%Y-%m-%d'
+        '%Y-%m-%d'
       end
 
     end

data/lib/compel/coercion/types/date_type.rb

@@ -6,7 +6,11 @@ module Compel
       attr_reader :format
 
       def coerce_value
-        @format = options[:format] || default_format
+        @format = default_format
+
+        if options[:format]
+          @format = options[:format][:value]
+        end
 
         if value.is_a?(klass)
           @value = value.strftime(format)

data/lib/compel/validation/conditions/condition.rb

@@ -15,14 +15,21 @@ module Compel
       def initialize(value, option_value, options = {})
         @value = value
         @value_type = options.delete(:type) || Coercion::Types::Any
+        @options = options
         @option_value = option_value
       end
 
       def validate
-        # result is an error message
-        result = validate_value
+        Validation::Result.new \
+          value, value_type, validate_value_with_error_message
+      end
+
+      private
+
+      def validate_value_with_error_message
+        error_message = validate_value
 
-        Validation::Result.new(value, value_type, result)
+        options[:message] || error_message
       end
 
     end

data/lib/compel/validation/validation.rb

@@ -27,16 +27,21 @@ module Compel
     }
 
     def validate(value, type, options)
-      if value.nil? && !!options[:required]
-        return ['is required']
+      if value.nil? && !!(options[:required] && options[:required][:value])
+        return [options[:required][:message] || 'is required']
       end
 
       errors = Errors.new
 
-      options.each do |option, option_value|
-        next unless condition_exists?(option)
+      options.each do |name, option_values|
+        next unless condition_exists?(name)
 
-        result = condition_klass(option).validate(value, option_value, type: type)
+        cloned_options = option_values.dup
+
+        option_value = cloned_options.delete(:value)
+
+        result = condition_klass(name).validate \
+          value, option_value, cloned_options.merge(type: type)
 
         unless result.valid?
           errors.add :base, result.error_message
@@ -46,12 +51,12 @@ module Compel
       errors.to_hash[:base] || []
     end
 
-    def condition_exists?(option)
-      CONDITIONS.keys.include?(option.to_sym)
+    def condition_exists?(option_name)
+      CONDITIONS.keys.include?(option_name.to_sym)
     end
 
-    def condition_klass(option)
-      CONDITIONS[option.to_sym]
+    def condition_klass(option_name)
+      CONDITIONS[option_name.to_sym]
     end
 
     extend self

data/lib/compel/validators/array_validator.rb

@@ -10,7 +10,7 @@ module Compel
 
         @errors = Errors.new
         @output = []
-        @items_schema = schema.options[:items]
+        @items_schema = schema.options[:items][:value] if schema.options[:items]
       end
 
       def validate

data/lib/compel/validators/hash_validator.rb

@@ -12,7 +12,7 @@ module Compel
         super
 
         @errors = Errors.new
-        @keys_schemas = schema.options[:keys]
+        @keys_schemas = schema.options[:keys][:value]
       end
 
       def validate

data/lib/compel/version.rb

@@ -1,3 +1,3 @@
 module Compel
-  VERSION = '0.4.0'
+  VERSION = '0.4.2'
 end

data/spec/compel/builder_spec.rb

@@ -1,3 +1,5 @@
+# encoding: UTF-8
+
 describe Compel::Builder do
 
   context 'Schema' do
@@ -22,7 +24,7 @@ describe Compel::Builder do
           it 'should have value' do
             [:in, :range].each do |method|
               builder.send(method, ["#{method}"])
-              expect(builder.options[method]).to eq(["#{method}"])
+              expect(builder.options[method][:value]).to eq(["#{method}"])
             end
           end
 
@@ -35,7 +37,7 @@ describe Compel::Builder do
           it 'should have value' do
             [:min, :max].each do |method|
               builder.send(method, "#{method}")
-              expect(builder.options[method]).to eq("#{method}")
+              expect(builder.options[method][:value]).to eq("#{method}")
             end
           end
 
@@ -50,10 +52,9 @@ describe Compel::Builder do
         context '#is, #default' do
 
           it 'should have value' do
-
             [:is, :default].each do |method|
               builder.send(method, "#{method}")
-              expect(builder.options[method]).to eq("#{method}")
+              expect(builder.options[method][:value]).to eq("#{method}")
             end
           end
 
@@ -78,7 +79,7 @@ describe Compel::Builder do
           it 'should have value' do
             builder.length(5)
 
-            expect(builder.options[:length]).to be 5
+            expect(builder.options[:length][:value]).to be 5
           end
 
           it 'should raise exception for invalid type' do
@@ -99,13 +100,13 @@ describe Compel::Builder do
           it 'should have value' do
             builder.format('%d-%m-%Y')
 
-            expect(builder.options[:format]).to eq('%d-%m-%Y')
+            expect(builder.options[:format][:value]).to eq('%d-%m-%Y')
           end
 
           it 'should have value' do
             builder.iso8601
 
-            expect(builder.options[:format]).to eq('%Y-%m-%d')
+            expect(builder.options[:format][:value]).to eq('%Y-%m-%d')
           end
 
         end
@@ -115,7 +116,7 @@ describe Compel::Builder do
           it 'should set max value with string and coerce' do
             builder.max('2016-01-01')
 
-            expect(builder.options[:max]).to eq(Date.new(2016, 1, 1))
+            expect(builder.options[:max][:value]).to eq(Date.new(2016, 1, 1))
           end
 
         end
@@ -125,8 +126,8 @@ describe Compel::Builder do
           it 'should set max value with string and coerce' do
             builder.in(['2016-01-01', '2016-01-02'])
 
-            expect(builder.options[:in]).to include(Date.new(2016, 1, 1))
-            expect(builder.options[:in]).to include(Date.new(2016, 1, 2))
+            expect(builder.options[:in][:value]).to include(Date.new(2016, 1, 1))
+            expect(builder.options[:in][:value]).to include(Date.new(2016, 1, 2))
           end
 
         end
@@ -156,7 +157,7 @@ describe Compel::Builder do
             each_date_builder do |builder, klass|
               builder.in([klass.new(2016, 1, 1), klass.new(2016, 1, 2)])
 
-              expect(builder.options[:in].length).to eq 2
+              expect(builder.options[:in][:value].length).to eq 2
             end
           end
 
@@ -174,7 +175,7 @@ describe Compel::Builder do
             each_date_builder do |builder, klass|
               builder.max(klass.new(2016, 1, 1))
 
-              expect(builder.options[:max]).to eq(klass.new(2016, 1, 1))
+              expect(builder.options[:max][:value]).to eq(klass.new(2016, 1, 1))
             end
           end
 
@@ -195,7 +196,7 @@ describe Compel::Builder do
             each_date_builder do |builder, klass|
               builder.min(klass.new(2016, 1, 1))
 
-              expect(builder.options[:min]).to eq(klass.new(2016, 1, 1))
+              expect(builder.options[:min][:value]).to eq(klass.new(2016, 1, 1))
             end
           end
 
@@ -221,7 +222,7 @@ describe Compel::Builder do
           it 'should set in value' do
             builder.in(['a', 'b'])
 
-            expect(builder.options[:in].length).to eq 2
+            expect(builder.options[:in][:value].length).to eq 2
           end
 
           it 'should raise exception for invalid item on array' do
@@ -243,7 +244,7 @@ describe Compel::Builder do
           it 'should have value' do
             builder.format(/1/)
 
-            expect(builder.options[:format]).to eq(/1/)
+            expect(builder.options[:format][:value]).to eq(/1/)
           end
 
         end
@@ -258,7 +259,7 @@ describe Compel::Builder do
           it 'should have value' do
             builder.min_length(4)
 
-            expect(builder.options[:min_length]).to eq(4)
+            expect(builder.options[:min_length][:value]).to eq(4)
           end
 
         end
@@ -273,7 +274,7 @@ describe Compel::Builder do
           it 'should have value' do
             builder.max_length(10)
 
-            expect(builder.options[:max_length]).to eq(10)
+            expect(builder.options[:max_length][:value]).to eq(10)
           end
 
         end
@@ -296,7 +297,7 @@ describe Compel::Builder do
             h: Compel.integer
           })
 
-          keys_schemas = schema.options[:keys]
+          keys_schemas = schema.options[:keys][:value]
 
           expect(keys_schemas[:a].type).to be Compel::Coercion::Float
           expect(keys_schemas[:b].type).to be Compel::Coercion::String
@@ -340,7 +341,7 @@ describe Compel::Builder do
         it 'should have value' do
           builder = Compel.array.items(Compel.integer)
 
-          expect(builder.options[:items].class).to be(Compel::Builder::Integer)
+          expect(builder.options[:items][:value].class).to be(Compel::Builder::Integer)
         end
 
       end
@@ -352,7 +353,7 @@ describe Compel::Builder do
           it 'should build schema' do
             builder = Compel.integer.min(10)
 
-            expect(builder.options[:min]).to eq(10)
+            expect(builder.options[:min][:value]).to eq(10)
           end
 
           it 'should raise exception for invalid value' do
@@ -382,6 +383,21 @@ describe Compel::Builder do
                 include('is required')
             end
 
+            it 'should have an array for error messages' do
+              schema = Compel.any.required(message: 'this is required')
+              expect(schema.validate(nil).errors.class).to eq Array
+
+              schema = Compel.any.required
+              expect(schema.validate(nil).errors.class).to eq Array
+            end
+
+            it 'should use custom error message' do
+              schema = Compel.any.required(message: 'this is required')
+
+              expect(schema.validate(nil).errors).to \
+                include('this is required')
+            end
+
           end
 
           context 'valid' do
@@ -468,6 +484,13 @@ describe Compel::Builder do
                 include('must be [1, 2, 3]')
             end
 
+            it 'should use custom error message' do
+              schema = Compel.any.is(1, message: 'not one')
+
+              expect(schema.validate('two').errors).to \
+                include('not one')
+            end
+
           end
 
           context 'valid' do
@@ -502,6 +525,13 @@ describe Compel::Builder do
                 include('cannot have length different than 1')
             end
 
+            it 'should use custom error message' do
+              schema = Compel.any.length(2, message: 'not the same size')
+
+              expect(schema.validate(12).errors).to \
+                include('not the same size')
+            end
+
           end
 
           context 'valid' do
@@ -526,6 +556,36 @@ describe Compel::Builder do
 
         end
 
+        context '#min_length' do
+
+          context 'invalid' do
+
+            it 'should use custom error message' do
+              schema = Compel.any.min_length(2, message: 'min is two')
+
+              expect(schema.validate(1).errors).to \
+                include('min is two')
+            end
+
+          end
+
+        end
+
+        context '#max_length' do
+
+          context 'invalid' do
+
+            it 'should use custom error message' do
+              schema = Compel.any.max_length(2, message: 'max is two')
+
+              expect(schema.validate(123).errors).to \
+                include('max is two')
+            end
+
+          end
+
+        end
+
       end
 
       context 'Hash' do
@@ -678,6 +738,12 @@ describe Compel::Builder do
             expect(result.valid?).to be false
           end
 
+          it 'should not validate and use custom error' do
+            result = Compel.string.url(message: 'not an URL').validate('url')
+
+            expect(result.errors).to include('not an URL')
+          end
+
         end
 
         context '#email' do
@@ -700,6 +766,12 @@ describe Compel::Builder do
             expect(result.valid?).to be false
           end
 
+          it 'should not validate and use custom error' do
+            result = Compel.string.email(message: 'not an EMAIL').validate('email')
+
+            expect(result.errors).to include('not an EMAIL')
+          end
+
         end
 
       end
@@ -884,6 +956,70 @@ describe Compel::Builder do
 
       end
 
+      context 'Integer' do
+
+        context '#in' do
+
+          context 'invalid' do
+
+            it 'should use custom error message' do
+              schema = Compel.integer.in([1, 2], message: 'not in 1 or 2')
+
+              expect(schema.validate(3).errors).to \
+                include('not in 1 or 2')
+            end
+
+          end
+
+        end
+
+        context '#range' do
+
+          context 'invalid' do
+
+            it 'should use custom error message' do
+              schema = Compel.integer.range([1, 2], message: 'not between 1 or 2')
+
+              expect(schema.validate(3).errors).to \
+                include('not between 1 or 2')
+            end
+
+          end
+
+        end
+
+        context '#min' do
+
+          context 'invalid' do
+
+            it 'should use custom error message' do
+              schema = Compel.integer.min(5, message: 'min is five')
+
+              expect(schema.validate(4).errors).to \
+                include('min is five')
+            end
+
+          end
+
+        end
+
+        context '#max' do
+
+          context 'invalid' do
+
+            it 'should use custom error message' do
+              schema = Compel.integer.max(5, message: 'max is five')
+
+              expect(schema.validate(6).errors).to \
+                include('max is five')
+            end
+
+          end
+
+        end
+
+      end
+
     end
 
   end

data/spec/compel/coercion_spec.rb

@@ -1,3 +1,5 @@
+# encoding: UTF-8
+
 describe Compel::Coercion do
 
   context 'Type coercion' do
@@ -67,7 +69,8 @@ describe Compel::Coercion do
       end
 
       it 'should coerce with format' do
-        value = Compel::Coercion.coerce!('22-12-2015', Compel::Coercion::Date, { format: '%d-%m-%Y' })
+        value = Compel::Coercion.coerce! \
+          '22-12-2015', Compel::Coercion::Date, { format: { value: '%d-%m-%Y' } }
 
         expect(value).to eq(Date.strptime('22-12-2015', '%d-%m-%Y'))
       end
@@ -98,7 +101,7 @@ describe Compel::Coercion do
       it 'should coerce' do
         [DateTime, Time].each do |time_klass|
           value = Compel::Coercion.coerce! \
-            '2015-12-22', Compel::Coercion.const_get("#{time_klass}"), format: '%Y-%m-%d'
+            '2015-12-22', Compel::Coercion.const_get("#{time_klass}"), format: { value: '%Y-%m-%d' }
 
           expect(value).to be_a time_klass
           expect(value.year).to eq(2015)

data/spec/compel/compel_spec.rb

@@ -1,3 +1,5 @@
+# encoding: UTF-8
+
 describe Compel do
 
   context '#run' do
@@ -360,6 +362,14 @@ describe Compel do
           expect(result.errors).to include('must match format ^\\d{4}-\\d{3}$')
         end
 
+        it 'should not compel with custom message' do
+          schema = Compel.string.format(/^\d{4}-\d{3}$/, message: 'this format is not good')
+
+          result = Compel.run('110-100', schema)
+
+          expect(result.errors).to include('this format is not good')
+        end
+
       end
 
     end

data/spec/compel/validation_spec.rb

@@ -3,13 +3,13 @@ describe Compel::Validation do
   context 'required' do
 
     it 'should validate without errors' do
-      errors = Compel::Validation.validate(123, Compel::Coercion::Integer, { required: true })
+      errors = Compel::Validation.validate(123, Compel::Coercion::Integer, { required: { value: true } })
 
       expect(errors.empty?).to eq(true)
     end
 
     it 'should validate with error' do
-      errors = Compel::Validation.validate(nil,  Compel::Coercion::Integer, { required: true })
+      errors = Compel::Validation.validate(nil, Compel::Coercion::Integer, { required: { value: true } })
 
       expect(errors.empty?).to eq(false)
       expect(errors).to eq(['is required'])
@@ -20,7 +20,7 @@ describe Compel::Validation do
   context 'length' do
 
     it 'should validate without errors' do
-      errors = Compel::Validation.validate(123,  Compel::Coercion::Integer, { length: 3 })
+      errors = Compel::Validation.validate(123, Compel::Coercion::Integer, { length: { value: 3 } })
 
       expect(errors.empty?).to eq(true)
     end
@@ -31,7 +31,7 @@ describe Compel::Validation do
 
     def expect_be_in_range(range, value)
       [:in, :range].each do |key|
-        errors = Compel::Validation.validate(value,  Compel::Coercion::String, { key => range })
+        errors = Compel::Validation.validate(value, Compel::Coercion::String, { key => { value: range } })
         yield errors
       end
     end
@@ -51,13 +51,13 @@ describe Compel::Validation do
     context 'range' do
 
       it 'should validate without errors' do
-        errors = Compel::Validation.validate(2, Compel::Coercion::Integer, range: (1..3))
+        errors = Compel::Validation.validate(2, Compel::Coercion::Integer, range: { value: (1..3) })
 
         expect(errors.empty?).to eq(true)
       end
 
       it 'should validate with errors' do
-        errors = Compel::Validation.validate(4, Compel::Coercion::Integer, range: (1..3))
+        errors = Compel::Validation.validate(4, Compel::Coercion::Integer, range: { value: (1..3) })
 
         expect(errors).to include('must be within 1..3')
       end
@@ -70,14 +70,14 @@ describe Compel::Validation do
 
     it 'should validate with errors' do
       format = /^abcd/
-      errors = Compel::Validation.validate('acb', Compel::Coercion::String, format: format)
+      errors = Compel::Validation.validate('acb', Compel::Coercion::String, format: { value: format })
 
       expect(errors).to include("must match format ^abcd")
     end
 
     it 'should validate without errors' do
       format = /abcd/
-      errors = Compel::Validation.validate('abcd', Compel::Coercion::String, format: format)
+      errors = Compel::Validation.validate('abcd', Compel::Coercion::String, format: { value: format })
       expect(errors.empty?).to eq(true)
     end
 
@@ -86,17 +86,17 @@ describe Compel::Validation do
   context 'is' do
 
     it 'should validate with errors' do
-      errors = Compel::Validation.validate('abcd', Compel::Coercion::Integer, is: 123)
+      errors = Compel::Validation.validate('abcd', Compel::Coercion::Integer, is: { value: 123 })
       expect(errors).to include('must be 123')
     end
 
     it 'should validate with errors 1' do
-      errors = Compel::Validation.validate(nil, Compel::Coercion::Integer, is: 123)
+      errors = Compel::Validation.validate(nil, Compel::Coercion::Integer, is: { value: 123 })
       expect(errors).to include('must be 123')
     end
 
     it 'should validate without errors' do
-      errors = Compel::Validation.validate(123, Compel::Coercion::Integer, is: 123)
+      errors = Compel::Validation.validate(123, Compel::Coercion::Integer, is: { value: 123 })
       expect(errors.empty?).to eq(true)
     end
 
@@ -105,31 +105,31 @@ describe Compel::Validation do
   context 'min' do
 
     it 'should validate without errors for Integer' do
-      errors = Compel::Validation.validate(2, Compel::Coercion::Integer, min: 1)
+      errors = Compel::Validation.validate(2, Compel::Coercion::Integer, min: { value: 1 })
 
       expect(errors.empty?).to be true
     end
 
     it 'should validate without errors for String' do
-      errors = Compel::Validation.validate('b', Compel::Coercion::String, min: 'a')
+      errors = Compel::Validation.validate('b', Compel::Coercion::String, min: { value: 'a' })
 
       expect(errors.empty?).to be true
     end
 
     it 'should validate with errors' do
-      errors = Compel::Validation.validate(1, Compel::Coercion::Integer, min: 3)
+      errors = Compel::Validation.validate(1, Compel::Coercion::Integer, min: { value: 3 })
 
       expect(errors).to include('cannot be less than 3')
     end
 
     it 'should validate with errors for String' do
-      errors = Compel::Validation.validate('a', Compel::Coercion::String, min: 'b')
+      errors = Compel::Validation.validate('a', Compel::Coercion::String, min: { value: 'b' })
 
       expect(errors).to include('cannot be less than b')
     end
 
     it 'should validate with errors for Float' do
-      errors = Compel::Validation.validate(1.54, Compel::Coercion::Float, min: 1.55)
+      errors = Compel::Validation.validate(1.54, Compel::Coercion::Float, min: { value: 1.55 })
 
       expect(errors).to include('cannot be less than 1.55')
     end
@@ -139,37 +139,37 @@ describe Compel::Validation do
   context 'max' do
 
     it 'should validate without errors' do
-      errors = Compel::Validation.validate(5, Compel::Coercion::Integer, min: 5)
+      errors = Compel::Validation.validate(5, Compel::Coercion::Integer, min: { value: 5 })
 
       expect(errors.empty?).to be true
     end
 
     it 'should validate with errors' do
-      errors = Compel::Validation.validate(3, Compel::Coercion::Integer, max: 2)
+      errors = Compel::Validation.validate(3, Compel::Coercion::Integer, max: { value: 2 })
 
       expect(errors).to include('cannot be greater than 2')
     end
 
     it 'should validate without errors for Integer' do
-      errors = Compel::Validation.validate(2, Compel::Coercion::Integer, max: 3)
+      errors = Compel::Validation.validate(2, Compel::Coercion::Integer, max: { value: 3 })
 
       expect(errors.empty?).to be true
     end
 
     it 'should validate without errors for String' do
-      errors = Compel::Validation.validate('b', Compel::Coercion::String, max: 'd')
+      errors = Compel::Validation.validate('b', Compel::Coercion::String, max: { value: 'd' })
 
       expect(errors.empty?).to be true
     end
 
     it 'should validate with errors for String' do
-      errors = Compel::Validation.validate('c', Compel::Coercion::String, max: 'b')
+      errors = Compel::Validation.validate('c', Compel::Coercion::String, max: { value: 'b' })
 
       expect(errors).to include('cannot be greater than b')
     end
 
     it 'should validate with errors for Float' do
-      errors = Compel::Validation.validate(1.56, Compel::Coercion::Float, max: 1.55)
+      errors = Compel::Validation.validate(1.56, Compel::Coercion::Float, max: { value: 1.55 })
 
       expect(errors).to include('cannot be greater than 1.55')
     end
@@ -179,19 +179,19 @@ describe Compel::Validation do
   context 'min_length' do
 
     it 'should validate with errors 1' do
-      errors = Compel::Validation.validate('a', Compel::Coercion::String, min_length: 2)
+      errors = Compel::Validation.validate('a', Compel::Coercion::String, min_length: { value: 2 })
 
       expect(errors).to include('cannot have length less than 2')
     end
 
     it 'should validate without errors' do
-      errors = Compel::Validation.validate('ab', Compel::Coercion::String, min_length: 2)
+      errors = Compel::Validation.validate('ab', Compel::Coercion::String, min_length: { value: 2 })
 
       expect(errors.empty?).to eq(true)
     end
 
     it 'should validate without errors 1' do
-      errors = Compel::Validation.validate(3, Compel::Coercion::Integer, min_length: 2)
+      errors = Compel::Validation.validate(3, Compel::Coercion::Integer, min_length: { value: 2 })
 
       expect(errors).to include('cannot have length less than 2')
     end
@@ -201,19 +201,19 @@ describe Compel::Validation do
   context 'max_length' do
 
     it 'should validate with errors 1' do
-      errors = Compel::Validation.validate('abcdef', Compel::Coercion::String, max_length: 5)
+      errors = Compel::Validation.validate('abcdef', Compel::Coercion::String, max_length: { value: 5 })
 
       expect(errors).to include('cannot have length greater than 5')
     end
 
     it 'should validate without errors' do
-      errors = Compel::Validation.validate('abcde', Compel::Coercion::String, max_length: 5)
+      errors = Compel::Validation.validate('abcde', Compel::Coercion::String, max_length: { value: 5 })
 
       expect(errors.empty?).to eq(true)
     end
 
     it 'should validate without errors 1' do
-      errors = Compel::Validation.validate(1, Compel::Coercion::Integer, max_length: 2)
+      errors = Compel::Validation.validate(1, Compel::Coercion::Integer, max_length: { value: 2 })
 
       expect(errors.empty?).to eq(true)
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: compel
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.4.2
 platform: ruby
 authors:
 - Joaquim Adráz
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-03-04 00:00:00.000000000 Z
+date: 2016-03-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -148,7 +148,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.4.6
 signing_key: 
 specification_version: 4
 summary: Ruby Object Coercion and Validation