fix(buildArray): Support tuple arrays

JSON Schema provides support for [tuple validation](https://spacetelescope.github.io/understanding-json-schema/reference/array.html#tuple-validation);
however, this module previously lacked support for it.

This commit will allow arrays to either be of a single type or to
be of mixed types in the order specified by the schema.

Author: elliotttf

index.js

@@ -402,7 +402,49 @@ function buildArray (schema, code, name, externalSchema, fullSchema) {
     schema.items = refFinder(schema.items['$ref'], fullSchema, externalSchema)
   }
 
-  var result = nested(laterCode, name, '[i]', schema.items, externalSchema, fullSchema)
+  var result = {code: '', laterCode: ''}
+  if (Array.isArray(schema.items)) {
+    result = schema.items.reduce((res, item, i) => {
+      var accessor = '[i]'
+      const tmpRes = nested(laterCode, name, accessor, item, externalSchema, fullSchema, i)
+      var condition
+      switch (item.type) {
+        case 'null':
+          condition = `obj${accessor} === null`
+          break
+        case 'string':
+          condition = `typeof obj${accessor} === 'string'`
+          break
+        case 'integer':
+          condition = `Number.isInteger(obj${accessor})`
+          break
+        case 'number':
+          condition = `!Number.isInteger(obj${accessor}) && Number.isFinite(obj${accessor})`
+          break
+        case 'boolean':
+          condition = `typeof obj${accessor} === 'boolean'`
+          break
+        case 'object':
+          condition = `obj${accessor} && typeof obj${accessor} === 'object' && obj${accessor}.constructor === Object`
+          break
+        case 'array':
+          condition = `Array.isArray(obj${accessor})`
+          break
+        default:
+          throw new Error(`${item.type} unsupported`)
+      }
+      return {
+        code: `${res.code}
+        if (${condition}) {
+          ${tmpRes.code}
+        }`,
+        laterCode: `${res.laterCode}
+        ${tmpRes.laterCode}`
+      }
+    }, result)
+  } else {
+    result = nested(laterCode, name, '[i]', schema.items, externalSchema, fullSchema)
+  }
 
   code += `
     var l = obj.length
@@ -428,7 +470,7 @@ function buildArray (schema, code, name, externalSchema, fullSchema) {
   return code
 }
 
-function nested (laterCode, name, key, schema, externalSchema, fullSchema) {
+function nested (laterCode, name, key, schema, externalSchema, fullSchema, subKey) {
   var code = ''
   var funcName
   var type = schema.type
@@ -460,14 +502,14 @@ function nested (laterCode, name, key, schema, externalSchema, fullSchema) {
       `
       break
     case 'object':
-      funcName = (name + key).replace(/[-.\[\]]/g, '') // eslint-disable-line
+      funcName = (name + key + subKey).replace(/[-.\[\]]/g, '') // eslint-disable-line
       laterCode = buildObject(schema, laterCode, funcName, externalSchema, fullSchema)
       code += `
         json += ${funcName}(obj${accessor})
       `
       break
     case 'array':
-      funcName = (name + key).replace(/[-.\[\]]/g, '') // eslint-disable-line
+      funcName = (name + key + subKey).replace(/[-.\[\]]/g, '') // eslint-disable-line
       laterCode = buildArray(schema, laterCode, funcName, externalSchema, fullSchema)
       code += `
         json += ${funcName}(obj${accessor})

test/array.test.js

@@ -0,0 +1,96 @@
+'use strict'
+
+const test = require('tap').test
+const validator = require('is-my-json-valid')
+const build = require('..')
+
+function buildTest (schema, toStringify) {
+  test(`render a ${schema.title} as JSON`, (t) => {
+    t.plan(5)
+
+    const validate = validator(schema)
+    const stringify = build(schema)
+    const stringifyUgly = build(schema, {uglify: true})
+    const output = stringify(toStringify)
+    const outputUglify = stringifyUgly(toStringify)
+
+    t.deepEqual(JSON.parse(output), toStringify)
+    t.deepEqual(JSON.parse(outputUglify), toStringify)
+    t.equal(output, JSON.stringify(toStringify))
+    t.equal(outputUglify, JSON.stringify(toStringify))
+    t.ok(validate(JSON.parse(output)), 'valid schema')
+  })
+}
+
+buildTest({
+  'title': 'string array',
+  'type': 'object',
+  'properties': {
+    'ids': {
+      'type': 'array',
+      'items': {
+        'type': 'string'
+      }
+    }
+  }
+}, {
+  ids: ['test']
+})
+
+buildTest({
+  'title': 'number array',
+  'type': 'object',
+  'properties': {
+    'ids': {
+      'type': 'array',
+      'items': {
+        'type': 'number'
+      }
+    }
+  }
+}, {
+  ids: [1]
+})
+
+buildTest({
+  'title': 'mixed array',
+  'type': 'object',
+  'properties': {
+    'ids': {
+      'type': 'array',
+      'items': [
+        {
+          'type': 'null'
+        },
+        {
+          'type': 'string'
+        },
+        {
+          'type': 'integer'
+        },
+        {
+          'type': 'number'
+        },
+        {
+          'type': 'boolean'
+        },
+        {
+          'type': 'object',
+          'properties': {
+            'a': {
+              'type': 'string'
+            }
+          }
+        },
+        {
+          'type': 'array',
+          'items': {
+            'type': 'string'
+          }
+        }
+      ]
+    }
+  }
+}, {
+  ids: [null, 'test', 1, 1.1, true, {a: 'test'}, ['test']]
+})