Fix nested use of type-check and custom types

Fixes #5

src/check.ls

@@ -21,57 +21,56 @@ default-type =
   array: 'Array'
   tuple: 'Array'
 
-function check-array input, type
-  all (-> check-multiple it, type.of), input
+function check-array input, type, options
+  all (-> check-multiple it, type.of, options), input
 
-function check-tuple input, type
+function check-tuple input, type, options
   i = 0
   for types in type.of
-    return false unless check-multiple input[i], types
+    return false unless check-multiple input[i], types, options
     i++
   input.length <= i # may be less if using 'Undefined' or 'Maybe' at the end
 
-function check-fields input, type
+function check-fields input, type, options
   input-keys = {}
   num-input-keys = 0
   for k of input
     input-keys[k] = true
     num-input-keys++
   num-of-keys = 0
   for key, types of type.of
-    return false unless check-multiple input[key], types
+    return false unless check-multiple input[key], types, options
     num-of-keys++ if input-keys[key]
   type.subset or num-input-keys is num-of-keys
 
-function check-structure input, type
+function check-structure input, type, options
   return false if input not instanceof Object
   switch type.structure
-  | 'fields' => check-fields input, type
-  | 'array'  => check-array input, type
-  | 'tuple'  => check-tuple input, type
+  | 'fields' => check-fields input, type, options
+  | 'array'  => check-array input, type, options
+  | 'tuple'  => check-tuple input, type, options
 
-function check input, type-obj
+function check input, type-obj, options
   {type, structure} = type-obj
   if type
     return true if type is '*' # wildcard
-    setting = custom-types[type] or types[type]
+    setting = options.custom-types[type] or types[type]
     if setting
       (setting.type-of is void or setting.type-of is typeof! input)
         and setting.validate input
     else
       # Booleam, String, Null, Undefined, Error, user defined objects, etc.
-      type is typeof! input and (not structure or check-structure input, type-obj)
+      type is typeof! input and (not structure or check-structure input, type-obj, options)
   else if structure
     return false unless that is typeof! input if default-type[structure]
-    check-structure input, type-obj
+    check-structure input, type-obj, options
   else
     throw new Error "No type defined. Input: #input."
 
-function check-multiple input, types
+function check-multiple input, types, options
   throw new Error "Types must be in an array. Input: #input." unless typeof! types is 'Array'
-  any (-> check input, it), types
+  any (-> check input, it, options), types
 
-var custom-types
 module.exports = (parsed-type, input, options = {}) ->
-  custom-types := options.custom-types or {}
-  check-multiple input, parsed-type
+  options.custom-types = {} unless options.custom-types
+  check-multiple input, parsed-type, options

test/check.ls

@@ -219,6 +219,18 @@ suite 'check' ->
       assert c 'str', 'foo', o
       assert not c 'str', 1, o
 
+    test 'nested check with custom types' ->
+      o =
+        custom-types:
+          A:
+            type-of: 'Object'
+            validate: -> c 'String', it.foo and it.foo = 'A'
+          B:
+            type-of: 'Object'
+            validate: -> c 'String', it.bar and it.bar = 'B'
+
+      assert c '{a: A, b: B}', {a: {foo: 'A'}, b: {bar: 'B'}}, o
+
   test 'nested' ->
     type = '{a: (String, [Number], {x: {a: Maybe Number}, y: Array, ...}), b: Error{message: String, ...}}'
     assert c type, {a: ['hi', [1, 2, 3], {x: {a: 42}, y: [1, 'bye']}], b: new Error 'message'}