compel 0.3.4 → 0.3.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bef1b2e1274aa8234be2702abb7267fb7663de84
-  data.tar.gz: 2a5d3146d9b59f2aaf54c8e552b721434774011c
+  metadata.gz: 6e6cfd90b9d392c7d5bf4f81be726f0e5b0f1444
+  data.tar.gz: 9ad55dcf253ce805dc407889fcc94fe659106329
 SHA512:
-  metadata.gz: 6b29767783dd35c1c9783499ae9f9c26dc773f7e09d37fba395ebe1d83d5fa167f496d39de056a45d7217578a973d86101a63580415cc716dcbeafb1b9af9d94
-  data.tar.gz: 645a9ea31ccce72d524e38f98567d3153630af64475b0c0ad506fe85b7977bc93ce5bd76cd452e6276aecba09316f019736e852f3defb1fc9a80e5e34459e936
+  metadata.gz: 35e2a1ff640dd63f43b9826a79fa4949b3a15da09e3c3eb517b6ac64f0763ed2cc2b3c2e8b04baec04ea6e9906edbdc3af84002fef4dff7210a01433b5bea70c
+  data.tar.gz: d4e7c4d9443609d922ea3adb3d664d21b3c49b5b8b278d3a46786ff33acfca330afde0f6f6746b41b58f9c9b4f7f39ef2f0518542c1b0516f7b8a461827475f3

data/README.md

@@ -77,6 +77,7 @@ Method  | Behaviour
 
 #### Compel#any
 `Any` referes to any type that is available to coerce with Compel.
+Methods `length`, `min_length` and `max_length` turn the object to validate into a `string` to compare the length.
 
 **Methods**:
 - `is(``value``)`
@@ -258,7 +259,7 @@ end
 
 Add this line to your application's Gemfile:
 
-    gem 'compel', '~> 0.3.4'
+    gem 'compel', '~> 0.3.5'
 
 And then execute:
 

data/lib/compel/builder/hash.rb

@@ -9,11 +9,29 @@ module Compel
         options[:keys] = {}
       end
 
-      def keys(hash)
-        options[:keys] = hash
+      def keys(object)
+        options[:keys] = coerce_keys_schemas(object)
         self
       end
 
+      private
+
+      def coerce_keys_schemas(object)
+        begin
+          fail if object.nil?
+
+          Coercion.coerce!(object, Coercion::Hash)
+        rescue
+          raise TypeError, 'Builder::Hash keys must be an Hash'
+        end
+
+        unless object.values.all?{|value| value.is_a?(Builder::Schema) }
+          raise TypeError, 'All Builder::Hash keys must be a valid Schema'
+        end
+
+        object
+      end
+
     end
 
   end

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

@@ -6,7 +6,7 @@ module Compel
       attr_accessor :value,
                     :options
 
-      def self.coerce(value, options)
+      def self.coerce(value, options = {})
         new(value, options).coerce
       end
 

data/lib/compel/validators/hash_validator.rb

@@ -91,7 +91,10 @@ module Compel
             next
           end
 
-          if input[key].is_a?(Hash)
+          if schemas[key].type == Coercion::Hash &&
+              (schemas[key].required? ||
+                !input[key].nil?)
+
             hash_validator = HashValidator.validate(input[key], schemas[key])
 
             errors.add(key, hash_validator.errors)

data/lib/compel/version.rb

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

data/spec/compel/builder_spec.rb

@@ -13,32 +13,6 @@ describe Compel::Builder do
         expect(builder.default_value).to be nil
       end
 
-      it 'should build Schema' do
-        schema = Compel.hash.keys({
-          a: Compel.float,
-          b: Compel.string,
-          c: Compel.hash.keys({
-            cc: Compel.integer.length(1)
-          }),
-          d: Compel.json,
-          e: Compel.time,
-          f: Compel.datetime,
-          g: Compel.date,
-          h: Compel.integer
-        })
-
-        keys_schemas = schema.options[:keys]
-
-        expect(keys_schemas.a.type).to be Compel::Coercion::Float
-        expect(keys_schemas.b.type).to be Compel::Coercion::String
-        expect(keys_schemas.c.type).to be Compel::Coercion::Hash
-        expect(keys_schemas.d.type).to be Compel::Coercion::JSON
-        expect(keys_schemas.e.type).to be Compel::Coercion::Time
-        expect(keys_schemas.f.type).to be Compel::Coercion::DateTime
-        expect(keys_schemas.g.type).to be Compel::Coercion::Date
-        expect(keys_schemas.h.type).to be Compel::Coercion::Integer
-      end
-
       context 'Builder::CommonValue' do
 
         context '#in, #range, #min, #max' do
@@ -176,30 +150,208 @@ describe Compel::Builder do
 
       end
 
+      context 'Hash' do
+
+        it 'should build Schema' do
+          schema = Compel.hash.keys({
+            a: Compel.float,
+            b: Compel.string,
+            c: Compel.hash.keys({
+              cc: Compel.integer.length(1)
+            }),
+            d: Compel.json,
+            e: Compel.time,
+            f: Compel.datetime,
+            g: Compel.date,
+            h: Compel.integer
+          })
+
+          keys_schemas = schema.options[:keys]
+
+          expect(keys_schemas.a.type).to be Compel::Coercion::Float
+          expect(keys_schemas.b.type).to be Compel::Coercion::String
+          expect(keys_schemas.c.type).to be Compel::Coercion::Hash
+          expect(keys_schemas.d.type).to be Compel::Coercion::JSON
+          expect(keys_schemas.e.type).to be Compel::Coercion::Time
+          expect(keys_schemas.f.type).to be Compel::Coercion::DateTime
+          expect(keys_schemas.g.type).to be Compel::Coercion::Date
+          expect(keys_schemas.h.type).to be Compel::Coercion::Integer
+        end
+
+        it 'should raise error for invalid #keys' do
+          expect{ Compel.hash.keys(nil) }.to \
+            raise_error(Compel::TypeError, 'Builder::Hash keys must be an Hash')
+        end
+
+        it 'should raise error for invalid #keys 1' do
+          expect{ Compel.hash.keys(1) }.to \
+            raise_error(Compel::TypeError, 'Builder::Hash keys must be an Hash')
+        end
+
+        it 'should raise error for invalid #keys Schema' do
+          expect{ Compel.hash.keys({ a: 1 }) }.to \
+            raise_error(Compel::TypeError, 'All Builder::Hash keys must be a valid Schema')
+        end
+
+      end
+
     end
 
     context 'Validate' do
 
       context 'Any' do
 
-        it 'should validate with errors and any type' do
-          schema = Compel.hash.keys({
-            a: Compel.any.required
-          })
+        context '#required' do
+
+          context 'invalid' do
+
+            it 'should validate a nil object' do
+              schema = Compel.any.required
+
+              expect(schema.validate(nil).errors).to \
+                include('is required')
+            end
+
+          end
+
+          context 'valid' do
+
+            it 'should validate nested hash object' do
+              schema = Compel.hash.keys({
+                a: Compel.any.required
+              });
+
+              result = schema.validate(a: { b: 1 })
+
+              expect(result.valid?).to be true
+            end
+
+            it 'should validate nested hash object 1' do
+              schema = Compel.hash.keys({
+                a: Compel.any.required
+              });
+
+              result = schema.validate(a: [])
+
+              expect(result.valid?).to be true
+            end
+
+            it 'should validate nested hash object 2' do
+              schema = Compel.hash.keys({
+                a: Compel.any.required
+              });
+
+              result = schema.validate(a: 1)
+
+              expect(result.valid?).to be true
+            end
+
+            it 'should validate an array object' do
+              schema = Compel.any.required
+
+              result = schema.validate([1, 2])
+
+              expect(result.valid?).to be true
+            end
+
+            it 'should validate an array object 1' do
+              schema = Compel.any.required
+
+              result = schema.validate([])
+
+              expect(result.valid?).to be true
+            end
+
+            it 'should validate a string object' do
+              schema = Compel.any.required
+
+              result = schema.validate('test')
+
+              expect(result.valid?).to be true
+            end
+
+          end
 
-          expect(schema.validate({ a: nil }).errors.a).to \
-            include('is required')
         end
 
         context '#is' do
 
-          it 'should validate without errors and any type' do
-            schema = Compel.hash.keys({
-              a: Compel.any.is(123)
-            })
+          context 'invalid' do
+
+            it 'should validate an integer' do
+              schema = Compel.any.is(123)
+
+              expect(schema.validate(122).errors).to \
+                include('must be 123')
+
+              expect(schema.validate('onetwothree').errors).to \
+                include('must be 123')
+            end
+
+            it 'should validate an array' do
+              schema = Compel.any.is([1, 2, 3])
+
+              expect(schema.validate([1]).errors).to \
+                include('must be [1, 2, 3]')
+
+              expect(schema.validate([]).errors).to \
+                include('must be [1, 2, 3]')
+            end
+
+          end
+
+          context 'valid' do
+
+            it 'should validate an array' do
+              schema = Compel.any.is([1, 2, 3])
+
+              result = schema.validate([1, 2, 3])
+
+              expect(result.valid?).to be true
+            end
+
+          end
+
+        end
+
+        context '#length' do
+
+          context 'invalid' do
+
+            it 'should not validate an instance object' do
+              schema = Compel.any.length(1)
+
+              expect(schema.validate(OpenStruct).errors).to \
+                include('cannot have length different than 1')
+            end
+
+            it 'should not validate a constant object' do
+              schema = Compel.any.length(1)
+
+              expect(schema.validate(OpenStruct).errors).to \
+                include('cannot have length different than 1')
+            end
+
+          end
+
+          context 'valid' do
+
+            it 'should validate a constant object' do
+              schema = Compel.any.length(10)
+
+              result = schema.validate(OpenStruct)
+
+              expect(result.valid?).to be true
+            end
+
+            it 'should validate a constant object' do
+              schema = Compel.any.length(10)
+
+              result = schema.validate(OpenStruct)
+
+              expect(result.valid?).to be true
+            end
 
-            expect(schema.validate({ a: 122 }).errors.a).to \
-              include('must be 123')
           end
 
         end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: compel
 version: !ruby/object:Gem::Version
-  version: 0.3.4
+  version: 0.3.6
 platform: ruby
 authors:
 - Joaquim Adráz
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-01-07 00:00:00.000000000 Z
+date: 2016-01-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: hashie