compel 0.3.6 → 0.3.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6e6cfd90b9d392c7d5bf4f81be726f0e5b0f1444
-  data.tar.gz: 9ad55dcf253ce805dc407889fcc94fe659106329
+  metadata.gz: dd80b5474b8218a24a20053cbf9a52645965acd3
+  data.tar.gz: c793b3161901f6aa6872b0763a7fb9570c9864d9
 SHA512:
-  metadata.gz: 35e2a1ff640dd63f43b9826a79fa4949b3a15da09e3c3eb517b6ac64f0763ed2cc2b3c2e8b04baec04ea6e9906edbdc3af84002fef4dff7210a01433b5bea70c
-  data.tar.gz: d4e7c4d9443609d922ea3adb3d664d21b3c49b5b8b278d3a46786ff33acfca330afde0f6f6746b41b58f9c9b4f7f39ef2f0518542c1b0516f7b8a461827475f3
+  metadata.gz: 78f27f5b101c0255540f8a99018d750247ddae79eca4847b1a656fbbd527e4af1445ce12567f5049b201fc1309bdd1b594af225876937b450689fc269f2b92c6
+  data.tar.gz: 6c1d7772d9cd20a21f6e36fe0f1c717bebb358a4a98ed2c3fb6831f986770895d4040901bf4a8ccc25e3b0ccd16cd72ae34ed0b142e9c02330bb83a4946c4ebf

data/README.md

@@ -37,29 +37,38 @@ schema = Compel.hash.keys({
   })
 })
 
-Compel.run(object, schema)
+Compel.run(object, schema) # or schema.validate(object)
 ```
 
-Will return an [Hashie::Mash](https://github.com/intridea/hashie) object:
+Will return a `Compel::Result` object:
 
 ```ruby
-{
-  "first_name" => "Joaquim",
-  "birth_date" => "1989-0",
-  "address" => {
-    "line_one" => "Lisboa",
-    "line_two" => "-",
-    "post_code" => "1100",
-    "country_code" => "PT"
-  },
-  "errors" => {
+=> <Compel::Result
+  @errors={
     "last_name" => ["is required"],
-    "birth_date" => ["'1989-0' is not a parsable date with format: %Y-%m-%d"],
+    "birth_date" => ["'1989-0' is not a parsable datetime with format: %FT%T"],
     "address" => {
-      "post_code" => ["must match format ^\d{4}-\d{3}$"]
+      "post_code" => ["must match format ^\\d{4}-\\d{3}$"]
     }
-  }
-}
+  },
+  @valid=false,
+  @value={
+    "first_name" => "Joaquim",
+    "birth_date" => "1989-0",
+    "address" => {
+      "line_one" => "Lisboa",
+      "post_code" => "1100",
+      "country_code" => "PT",
+      "line_two" => "-"
+    },
+    "errors" => {
+      "last_name" => ["is required"],
+      "birth_date" => ["'1989-0' is not a parsable datetime with format: %FT%T"],
+      "address" => {
+        "post_code" => ["must match format ^\\d{4}-\\d{3}$"]
+      }
+    }
+  }>
 ```
 
 There are 4 ways to run validations:
@@ -259,7 +268,7 @@ end
 
 Add this line to your application's Gemfile:
 
-    gem 'compel', '~> 0.3.5'
+    gem 'compel', '~> 0.3.7'
 
 And then execute:
 

data/lib/compel/builder/common.rb

@@ -4,7 +4,7 @@ module Compel
     module Common
 
       def is(value)
-        options[:is] = value
+        options[:is] = Coercion.coerce!(value, self.type)
         self
       end
 
@@ -14,7 +14,7 @@ module Compel
       end
 
       def default(value)
-        options[:default] = value
+        options[:default] = Coercion.coerce!(value, self.type)
         self
       end
 

data/lib/compel/builder/common_value.rb

@@ -4,25 +4,65 @@ module Compel
     module CommonValue
 
       def in(value)
-        options[:in] = value
+        options[:in] = coerce_values_ary!(value, :in)
         self
       end
 
       def range(value)
-        options[:range] = value
+        options[:range] = coerce_values_ary!(value, :range)
         self
       end
 
       def min(value)
-        options[:min] = value
+        options[:min] = coerce_value!(value, :min)
         self
       end
 
       def max(value)
-        options[:max] = value
+        options[:max] = coerce_value!(value, :max)
         self
       end
 
+      def coerce_values_ary!(values, method)
+        begin
+          fail if values.nil?
+
+          Coercion.coerce!(values, Coercion::Array)
+        rescue
+          raise_array_error(method)
+        end
+
+        values.map{ |value| Coercion.coerce!(value, self.type) }
+
+        rescue
+          raise_array_values_error(method)
+      end
+
+      def coerce_value!(value, method)
+        begin
+          fail if value.nil?
+
+          Coercion.coerce!(value, self.type)
+        rescue
+          raise_value_error(method)
+        end
+      end
+
+      def raise_array_error(method)
+        raise TypeError, "#{self.class.human_name} ##{method} " \
+                         "value must an Array"
+      end
+
+      def raise_array_values_error(method)
+        raise TypeError, "All #{self.class.human_name} ##{method} values " \
+                         "must be a valid #{self.type.human_name}"
+      end
+
+      def raise_value_error(method)
+        raise TypeError, "#{self.class.human_name} ##{method} value " \
+                         "must be a valid #{self.type.human_name}"
+      end
+
     end
 
   end

data/lib/compel/builder/date.rb

@@ -3,6 +3,8 @@ module Compel
 
     class Date < Schema
 
+      include CommonValue
+
       def initialize
         super(Coercion::Date)
       end

data/lib/compel/builder/datetime.rb

@@ -3,6 +3,8 @@ module Compel
 
     class DateTime < Schema
 
+      include CommonValue
+
       def initialize
         super(Coercion::DateTime)
       end

data/lib/compel/builder/schema.rb

@@ -10,11 +10,11 @@ module Compel
 
       def initialize(type)
         @type = type
-        @options = Hashie::Mash.new
+        @options = default_options
       end
 
       def required?
-        !!options[:required]
+        options[:required]
       end
 
       def default_value
@@ -25,6 +25,20 @@ module Compel
         Contract.new(object, self).validate
       end
 
+      class << self
+
+        def human_name
+          "#{self.name.split('::')[1..-1].join('::')}"
+        end
+
+      end
+
+      protected
+
+      def default_options
+        Hashie::Mash.new(required: false)
+      end
+
     end
 
   end

data/lib/compel/builder/string.rb

@@ -3,6 +3,14 @@ module Compel
 
     class String < Schema
 
+      # Taken from ruby_regex gem by @eparreno
+      # https://github.com/eparreno/ruby_regex
+      URL_REGEX = /(\A\z)|(\A(http|https):\/\/[a-z0-9]+([\-\.]{1}[a-z0-9]+)*\.[a-z]{2,5}(([0-9]{1,5})?\/.*)?\z)/ix
+
+      # Taken from Michael Hartl's 'The Ruby on Rails Tutorial'
+      # https://www.railstutorial.org/book
+      EMAIL_REGEX = /\A[\w+\-.]+@[a-z\d\-]+(\.[a-z]+)*\.[a-z]+\z/i
+
       include CommonValue
 
       def initialize
@@ -14,6 +22,16 @@ module Compel
         self
       end
 
+      def url
+        options[:format] = URL_REGEX
+        self
+      end
+
+      def email
+        options[:format] = EMAIL_REGEX
+        self
+      end
+
     end
 
   end

data/lib/compel/builder/time.rb

@@ -3,6 +3,8 @@ module Compel
 
     class Time < Schema
 
+      include CommonValue
+
       def initialize
         super(Coercion::Time)
       end

data/lib/compel/coercion/coercion.rb

@@ -1,4 +1,5 @@
 require 'compel/coercion/types/type'
+require 'compel/coercion/types/date_type'
 require 'compel/coercion/types/integer'
 require 'compel/coercion/types/float'
 require 'compel/coercion/types/string'

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

@@ -1,33 +1,14 @@
 module Compel
   module Coercion
 
-    class Date < Type
+    class Date < DateType
 
-      attr_reader :format
-
-      def coerce_value
-        @format = options[:format] || '%Y-%m-%d'
-
-        if value.is_a?(::Date)
-          @value = value.strftime(format)
-        end
-
-        coerced = ::Date.strptime(value, format)
-
-        if coerced.strftime(format) == value
-          return coerced
-        end
-
-        build_error_result
-
-        rescue
-          build_error_result
+      def klass
+        ::Date
       end
 
-      def build_error_result
-        custom_error = "'#{value}' is not a parsable date with format: #{format}"
-
-        Result.new(nil, value, self.class, custom_error)
+      def default_format
+         '%Y-%m-%d'
       end
 
     end

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

@@ -0,0 +1,36 @@
+module Compel
+  module Coercion
+
+    class DateType < Type
+
+      attr_reader :format
+
+      def coerce_value
+        @format = options[:format] || default_format
+
+        if value.is_a?(klass)
+          @value = value.strftime(format)
+        end
+
+        coerced = klass.strptime(value, format)
+
+        if coerced.strftime(format) == value
+          return coerced
+        end
+
+        build_error_result
+
+        rescue
+          build_error_result
+      end
+
+      def build_error_result
+        custom_error = "'#{value}' is not a parsable #{klass.to_s.downcase} with format: #{format}"
+
+        Result.new(nil, value, self.class, custom_error)
+      end
+
+    end
+
+  end
+end

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

@@ -1,33 +1,14 @@
 module Compel
   module Coercion
 
-    class DateTime < Type
+    class DateTime < DateType
 
-      attr_reader :format
-
-      def coerce_value
-        @format = options[:format] || '%FT%T'
-
-        if value.is_a?(::DateTime)
-          @value = value.strftime(format)
-        end
-
-        coerced = ::DateTime.strptime(value, format)
-
-        if coerced.strftime(format) == value
-          return coerced
-        end
-
-        build_error_result
-
-        rescue
-          build_error_result
+      def klass
+        ::DateTime
       end
 
-      def build_error_result
-        custom_error = "'#{value}' is not a parsable datetime with format: #{format}"
-
-        Result.new(nil, value, self.class, custom_error)
+      def default_format
+        '%FT%T'
       end
 
     end

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

@@ -1,33 +1,14 @@
 module Compel
   module Coercion
 
-    class Time < Type
+    class Time < DateType
 
-      attr_reader :format
-
-      def coerce_value
-        @format = options[:format] || '%FT%T'
-
-        if value.is_a?(::Time)
-          @value = value.strftime(format)
-        end
-
-        coerced = ::Time.strptime(value, format)
-
-        if coerced.strftime(format) == value
-          return coerced
-        end
-
-        build_error_result
-
-        rescue
-          build_error_result
+      def klass
+        ::Time
       end
 
-      def build_error_result
-        custom_error = "'#{value}' is not a parsable time with format: #{format}"
-
-        Result.new(nil, value, self.class, custom_error)
+      def default_format
+        '%FT%T'
       end
 
     end

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

@@ -27,6 +27,14 @@ module Compel
         Coercion::Result.new(result, value, self.class)
       end
 
+      class << self
+
+        def human_name
+          "#{self.name.split('::')[-1]}"
+        end
+
+      end
+
     end
 
   end

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

@@ -17,8 +17,6 @@ module Compel
 
     end
 
-    class Within < In; end
-
     class Range < In; end
 
   end

data/lib/compel/validation/validation.rb

@@ -20,7 +20,6 @@ module Compel
       min: Validation::Min,
       max: Validation::Max,
       range: Validation::Range,
-      within: Validation::Within,
       format: Validation::Format,
       length: Validation::Length,
       min_length: Validation::MinLength,

data/lib/compel/version.rb

@@ -1,3 +1,3 @@
 module Compel
-  VERSION = '0.3.6'
+  VERSION = '0.3.7'
 end

data/lib/compel.rb

@@ -1,3 +1,4 @@
+require 'time'
 require 'hashie'
 
 require 'compel/exceptions/type_error'

data/spec/compel/builder_spec.rb

@@ -8,19 +8,32 @@ describe Compel::Builder do
         builder = Compel.string
 
         expect(builder.type).to be(Compel::Coercion::String)
-        expect(builder.options.keys).to eq([])
+        expect(builder.options.keys).to include('required')
         expect(builder.required?).to be false
         expect(builder.default_value).to be nil
       end
 
       context 'Builder::CommonValue' do
 
-        context '#in, #range, #min, #max' do
+        context '#in, #range' do
 
           subject(:builder) { Compel.string }
 
           it 'should have value' do
-            [:in, :range, :min, :max].each do |method|
+            [:in, :range].each do |method|
+              builder.send(method, ["#{method}"])
+              expect(builder.options[method]).to eq(["#{method}"])
+            end
+          end
+
+        end
+
+        context '#min, #max' do
+
+          subject(:builder) { Compel.string }
+
+          it 'should have value' do
+            [:min, :max].each do |method|
               builder.send(method, "#{method}")
               expect(builder.options[method]).to eq("#{method}")
             end
@@ -97,12 +110,129 @@ describe Compel::Builder do
 
         end
 
+        context '#max' 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))
+          end
+
+        end
+
+        context '#in' 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))
+          end
+
+        end
+
+      end
+
+      context 'Date, DateTime and Time' do
+
+        def each_date_builder
+          [Date, DateTime, Time].each do |klass|
+            builder = Compel.send("#{klass.to_s.downcase}")
+
+            yield builder, klass
+          end
+        end
+
+        context 'in' do
+
+          def expect_raise_error_for(builder, values, klass)
+            expect{ builder.in(values) }.to \
+              raise_error \
+                Compel::TypeError,
+                  "All Builder::#{klass} #in values must be a valid #{klass}"
+          end
+
+          it 'should set in value' 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
+            end
+          end
+
+          it 'should raise exception for invalid #in values' do
+            each_date_builder do |builder, klass|
+              expect_raise_error_for(builder, [klass.new(2016, 1, 1), 'invalid_date'], klass)
+            end
+          end
+
+        end
+
+        context '#max' do
+
+          it 'should set max value' 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))
+            end
+          end
+
+          it 'should raise exception for invalid value' do
+            each_date_builder do |builder, klass|
+              expect{ builder.max(1) }.to \
+                raise_error \
+                  Compel::TypeError,
+                    "Builder::#{klass} #max value must be a valid #{klass}"
+            end
+          end
+
+        end
+
+        context '#min' do
+
+          it 'should set min value' 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))
+            end
+          end
+
+          it 'should raise exception for invalid value' do
+            each_date_builder do |builder, klass|
+              expect{ builder.min(1) }.to \
+                raise_error \
+                  Compel::TypeError,
+                    "Builder::#{klass} #min value must be a valid #{klass}"
+            end
+          end
+
+        end
+
       end
 
       context 'String' do
 
         subject(:builder) { Compel.string }
 
+        context 'in' do
+
+          it 'should set in value' do
+            builder.in(['a', 'b'])
+
+            expect(builder.options[:in].length).to eq 2
+          end
+
+          it 'should raise exception for invalid item on array' do
+            expect{ builder.in([1, 'b']) }.to \
+              raise_error \
+                Compel::TypeError,
+                  "All Builder::String #in values must be a valid String"
+          end
+
+        end
+
         context '#format' do
 
           it 'should raise exception for invalid type' do
@@ -195,6 +325,46 @@ describe Compel::Builder do
 
       end
 
+      context 'Array' do
+
+        it 'should raise exception for invalid type' do
+          expect { Compel.array.items('a') }.to \
+            raise_error Compel::TypeError, "#items must be a valid Schema"
+        end
+
+        it 'should raise exception for invalid type' do
+          expect { Compel.array.items('a') }.to \
+            raise_error Compel::TypeError, "#items must be a valid Schema"
+        end
+
+        it 'should have value' do
+          builder = Compel.array.items(Compel.integer)
+
+          expect(builder.options[:items].class).to be(Compel::Builder::Integer)
+        end
+
+      end
+
+      context 'Integer' do
+
+        context 'min' do
+
+          it 'should build schema' do
+            builder = Compel.integer.min(10)
+
+            expect(builder.options[:min]).to eq(10)
+          end
+
+          it 'should raise exception for invalid value' do
+            expect{ Compel.integer.min('ten') }.to \
+              raise_error \
+                Compel::TypeError, 'Builder::Integer #min value must be a valid Integer'
+          end
+
+        end
+
+      end
+
     end
 
     context 'Validate' do
@@ -414,6 +584,26 @@ describe Compel::Builder do
             include('is required')
         end
 
+        context '#required' do
+
+          it 'should validate empty keys option' do
+            schema = Compel.hash.required
+
+            expect(schema.validate({ a: 1 }).valid?).to be true
+          end
+
+          it 'should validate nil' do
+            schema = Compel.hash.required
+
+            result = schema.validate(nil)
+
+            expect(result.valid?).to be false
+            expect(result.errors[:base]).to \
+              include('is required')
+          end
+
+        end
+
         context '#is' do
 
           it 'should validate with errors' do
@@ -438,6 +628,18 @@ describe Compel::Builder do
 
         end
 
+        context '#length' do
+
+          it 'should validate empty keys with errors' do
+            result = Compel.hash.length(2).validate({ a: 1 })
+
+            expect(result.valid?).to be false
+            expect(result.errors[:base]).to \
+              include('cannot have length different than 2')
+          end
+
+        end
+
       end
 
       context 'String' do
@@ -450,26 +652,74 @@ describe Compel::Builder do
             include("must match format ^\\d{4}-\\d{3}$")
         end
 
+        context '#url' do
+
+          it 'should validate' do
+            result = Compel.string.url.validate('http://example.com')
+
+            expect(result.valid?).to be true
+          end
+
+          it 'should validate' do
+            result = Compel.string.url.validate('http://app.com/posts/1/comments')
+
+            expect(result.valid?).to be true
+          end
+
+          it 'should not validate' do
+            result = Compel.string.url.validate('www.example.com')
+
+            expect(result.valid?).to be false
+          end
+
+          it 'should not validate' do
+            result = Compel.string.url.validate('url')
+
+            expect(result.valid?).to be false
+          end
+
+        end
+
+        context '#email' do
+
+          it 'should validate' do
+            result = Compel.string.email.validate('example@gmail.com')
+
+            expect(result.valid?).to be true
+          end
+
+          it 'should not validate' do
+            result = Compel.string.email.validate('example@gmail')
+
+            expect(result.valid?).to be false
+          end
+
+          it 'should not validate' do
+            result = Compel.string.email.validate('email')
+
+            expect(result.valid?).to be false
+          end
+
+        end
+
       end
 
       context 'Array' do
 
-        subject(:builder) { Compel.array }
-
         it 'should validate nil without errors' do
-          result = builder.validate(nil)
+          result = Compel.array.validate(nil)
 
           expect(result.valid?).to be true
         end
 
         it 'should validate nil with errors' do
-          result = builder.required.validate(nil)
+          result = Compel.array.required.validate(nil)
 
           expect(result.errors[:base]).to include('is required')
         end
 
         it 'should validate with errors for invalid array' do
-          result = builder.required.validate(1)
+          result = Compel.array.required.validate(1)
 
           expect(result.errors[:base]).to include("'1' is not a valid Array")
         end
@@ -477,41 +727,21 @@ describe Compel::Builder do
         context '#items' do
 
           it 'should validate without items' do
-            result = builder.validate([1, 2, 3])
+            result = Compel.array.validate([1, 2, 3])
 
             expect(result.valid?).to be true
             expect(result.value).to eq([1, 2, 3])
           end
 
-          it 'should raise exception for invalid type' do
-            expect { builder.items('a') }.to \
-              raise_error Compel::TypeError, "#items must be a valid Schema"
-          end
-
-          it 'should raise exception for invalid type' do
-            expect { builder.items('a') }.to \
-              raise_error Compel::TypeError, "#items must be a valid Schema"
-          end
-
-          it 'should have value' do
-            builder.items(Compel.integer)
-
-            expect(builder.options[:items].class).to be(Compel::Builder::Integer)
-          end
-
           it 'should validate all items' do
-            builder.items(Compel.integer)
-
-            result = builder.validate([1, '2', nil])
+            result = Compel.array.items(Compel.integer).validate([1, '2', nil])
 
             expect(result.valid?).to be true
             expect(result.value).to eq([1, 2])
           end
 
           it 'should validate all items with errors' do
-            builder.items(Compel.float.required)
-
-            result = builder.validate([1, 'a', nil])
+            result = Compel.array.items(Compel.float.required).validate([1, 'a', nil])
 
             expect(result.valid?).to be false
             expect(result.errors['1']).to include("'a' is not a valid Float")
@@ -519,7 +749,7 @@ describe Compel::Builder do
           end
 
           it 'should coerce all hash items' do
-            builder.items(Compel.hash.keys({
+            builder = Compel.array.items(Compel.hash.keys({
               a: Compel.string.required,
               b: Compel.integer
             }))
@@ -540,7 +770,7 @@ describe Compel::Builder do
           end
 
           it 'should coerce all hash items with errors' do
-            builder.items(Compel.hash.keys({
+            builder = Compel.array.items(Compel.hash.keys({
               a: Compel.string.required,
               b: Compel.string.format(/^abc$/).required
             }))
@@ -569,7 +799,7 @@ describe Compel::Builder do
           end
 
           it 'should coerce array with hash items and nested array keys with errors' do
-            builder.items(Compel.hash.keys({
+            builder = Compel.array.items(Compel.hash.keys({
               a: Compel.string,
               b: Compel.array.items(Compel.integer.required).required
             }))
@@ -626,16 +856,14 @@ describe Compel::Builder do
 
           it 'should validate with errors' do
             value = [1, 2, 3]
-            schema = builder.is(value)
-            result = schema.validate([1, 2])
+            result = Compel.array.is(value).validate([1, 2])
 
             expect(result.valid?).to be false
             expect(result.errors[:base]).to include("must be #{value}")
           end
 
           it 'should validate without errors' do
-            schema = builder.is(['a', 'b', 'c'])
-            result = schema.validate(['a', 'b', 'c'])
+            result = Compel.array.is(['a', 'b', 'c']).validate(['a', 'b', 'c'])
 
             expect(result.valid?).to be true
           end
@@ -644,34 +872,14 @@ describe Compel::Builder do
 
       end
 
-      context 'Hash' do
+      context 'DateTime' do
 
-        subject(:builder) { Compel.hash }
-
-        it 'should validate empty keys option' do
-          schema = builder.required
-
-          expect(schema.validate({ a: 1 }).valid?).to be true
-        end
-
-        it 'should validate nil' do
-          schema = builder.required
-
-          result = schema.validate(nil)
-
-          expect(result.valid?).to be false
-          expect(result.errors[:base]).to \
-            include('is required')
-        end
-
-        it 'should validate empty keys with errors' do
-          schema = builder.required.length(2)
-
-          result = schema.validate({ a: 1 })
+        it 'should validate with errors' do
+          result = Compel.datetime.validate('1989-0')
 
           expect(result.valid?).to be false
-          expect(result.errors[:base]).to \
-            include('cannot have length different than 2')
+          expect(result.errors).to \
+            include("'1989-0' is not a parsable datetime with format: %FT%T")
         end
 
       end

data/spec/compel/validation_spec.rb

@@ -27,23 +27,23 @@ describe Compel::Validation do
 
   end
 
-  context 'in, within, range' do
+  context 'in, range' do
 
-    def expect_be_in_within_range(range, value)
-      [:in, :within].each do |key|
+    def expect_be_in_range(range, value)
+      [:in, :range].each do |key|
         errors = Compel::Validation.validate(value,  Compel::Coercion::String, { key => range })
         yield errors
       end
     end
 
     it 'should validate without errors' do
-      expect_be_in_within_range(['PT', 'UK'], 'PT') do |errors|
+      expect_be_in_range(['PT', 'UK'], 'PT') do |errors|
         expect(errors.empty?).to eq(true)
       end
     end
 
     it 'should validate with errors' do
-      expect_be_in_within_range(['PT', 'UK'], 'US') do |errors|
+      expect_be_in_range(['PT', 'UK'], 'US') do |errors|
         expect(errors).to include('must be within ["PT", "UK"]')
       end
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: compel
 version: !ruby/object:Gem::Version
-  version: 0.3.6
+  version: 0.3.7
 platform: ruby
 authors:
 - Joaquim Adráz
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-01-08 00:00:00.000000000 Z
+date: 2016-01-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: hashie
@@ -104,6 +104,7 @@ files:
 - lib/compel/coercion/types/array.rb
 - lib/compel/coercion/types/boolean.rb
 - lib/compel/coercion/types/date.rb
+- lib/compel/coercion/types/date_type.rb
 - lib/compel/coercion/types/datetime.rb
 - lib/compel/coercion/types/float.rb
 - lib/compel/coercion/types/hash.rb