Merge pull request #7 from mcollina/pattern-properties

Pattern properties support

Author: delvedor

README.md

@@ -58,6 +58,7 @@ Build a `stringify()` function based on
 
 Supported types:
 
+ * `'string'`
  * `'integer'`
  * `'number'`
  * `'array'`
@@ -106,10 +107,10 @@ const stringify = fastJson({
       type: 'string'
     },
     mail: {
-      type: 'string',
-      required: true
+      type: 'string'
     }
-  }
+  },
+  required: ['mail']
 })
 
 const obj = {
@@ -119,6 +120,40 @@ const obj = {
 console.log(stringify(obj)) // '{"mail":"mail@example.com"}'
 ```
 
+#### Pattern properties
+`fast-json-stringify` supports pattern properties as defined inside JSON schema.  
+*patternProperties* must be an object, where the key is a valid regex and the value is an object, declared in this way: `{ type: 'type' }`.  
+*patternProperties* will work only for the properties that are not explicitly listed in the properties object.  
+Example:
+```javascript
+const stringify = fastJson({
+  title: 'Example Schema',
+  type: 'object',
+  properties: {
+    nickname: {
+      type: 'string'
+    }
+  },
+  patternProperties: {
+    'num': {
+      type: 'number'
+    },
+    '.*foo$': {
+      type: 'string'
+    }
+  }
+})
+
+const obj = {
+  nickname: 'nick',
+  matchfoo: 42,
+  otherfoo: 'str'
+  matchnum: 3
+}
+
+console.log(stringify(obj)) // '{"nickname":"nick","matchfoo":"42","otherfoo":"str","matchnum":3}'
+```
+
 ## Acknowledgements
 
 This project was kindly sponsored by [nearForm](http://nearform.com).

example.js

@@ -20,15 +20,48 @@ const stringify = fastJson({
     },
     reg: {
       type: 'string'
+    },
+    obj: {
+      type: 'object',
+      properties: {
+        bool: {
+          type: 'boolean'
+        }
+      }
+    },
+    arr: {
+      type: 'array',
+      items: {
+        type: 'object',
+        properties: {
+          str: {
+            type: 'string'
+          }
+        }
+      }
     }
   },
-  required: ['now']
+  required: ['now'],
+  patternProperties: {
+    '.*foo$': {
+      type: 'string'
+    },
+    'test': {
+      type: 'number'
+    }
+  }
 })
 
 console.log(stringify({
   firstName: 'Matteo',
   lastName: 'Collina',
   age: 32,
   now: new Date(),
-  reg: /"([^"]|\\")*"/
+  reg: /"([^"]|\\")*"/,
+  foo: 'hello',
+  numfoo: 42,
+  test: 42,
+  strtest: '23',
+  arr: [{ str: 'stark' }, { str: 'lannister' }],
+  obj: { bool: true }
 }))

index.js

@@ -4,7 +4,13 @@ function build (schema) {
   /*eslint no-new-func: "off"*/
   var code = `
     'use strict'
-
+  `
+  // used to support patternProperties and additionalProperties
+  // they need to check if a field belongs to the properties in the schema
+  code += `
+    const properties = ${JSON.stringify(schema.properties)}
+  `
+  code += `
     ${$asString.toString()}
     ${$asStringSmall.toString()}
     ${$asStringLong.toString()}
@@ -58,7 +64,7 @@ function $asNumber (i) {
   if (isNaN(num)) {
     return 'null'
   } else {
-    return '' + i
+    return '' + num
   }
 }
 
@@ -131,11 +137,67 @@ function $asRegExp (reg) {
   return '"' + reg + '"'
 }
 
+function addPatternProperties (pp) {
+  let code = `
+      var keys = Object.keys(obj)
+      for (var i = 0; i < keys.length; i++) {
+        if (properties[keys[i]]) continue
+  `
+  Object.keys(pp).forEach((regex, index) => {
+    var type = pp[regex].type
+    code += `
+        if (/${regex}/.test(keys[i])) {
+    `
+    if (type === 'object') {
+      code += buildObject(pp[regex], '', 'buildObjectPP' + index)
+      code += `
+          json += $asString(keys[i]) + ':' + buildObjectPP${index}(obj[keys[i]]) + ','
+      `
+    } else if (type === 'array') {
+      code += buildArray(pp[regex], '', 'buildArrayPP' + index)
+      code += `
+          json += $asString(keys[i]) + ':' + buildArrayPP${index}(obj[keys[i]]) + ','
+      `
+    } else if (type === 'null') {
+      code += `
+          json += $asString(keys[i]) +':null,'
+      `
+    } else if (type === 'string') {
+      code += `
+          json += $asString(keys[i]) + ':' + $asString(obj[keys[i]]) + ','
+      `
+    } else if (type === 'number' || type === 'integer') {
+      code += `
+          json += $asString(keys[i]) + ':' + $asNumber(obj[keys[i]]) + ','
+      `
+    } else if (type === 'boolean') {
+      code += `
+          json += $asString(keys[i]) + ':' + $asBoolean(obj[keys[i]]) + ','
+      `
+    } else {
+      code += `
+          throw new Error('Cannot coerce ' + obj[keys[i]] + ' to ${type}')
+      `
+    }
+    code += `
+        }
+    `
+  })
+  code += `
+      }
+      if (Object.keys(properties).length === 0) json = json.substring(0, json.length - 1)
+  `
+  return code
+}
+
 function buildObject (schema, code, name) {
   code += `
     function ${name} (obj) {
       var json = '{'
   `
+  if (schema.patternProperties) {
+    code += addPatternProperties(schema.patternProperties)
+  }
 
   var laterCode = ''
 
@@ -177,7 +239,6 @@ function buildObject (schema, code, name) {
   `
 
   code += laterCode
-
   return code
 }
 

test.js

@@ -316,3 +316,160 @@ test('missing values', (t) => {
   t.equal('{"str":"string","val":"value"}', stringify({ str: 'string', val: 'value' }))
   t.equal('{"str":"string","num":42,"val":"value"}', stringify({ str: 'string', num: 42, val: 'value' }))
 })
+
+test('patternProperties', (t) => {
+  t.plan(1)
+  const stringify = build({
+    title: 'patternProperties',
+    type: 'object',
+    properties: {
+      str: {
+        type: 'string'
+      }
+    },
+    patternProperties: {
+      'foo': {
+        type: 'string'
+      }
+    }
+  })
+
+  let obj = { str: 'test', foo: 42, ofoo: true, foof: 'string', objfoo: {a: true}, notMe: false }
+  t.equal('{"foo":"42","ofoo":"true","foof":"string","objfoo":"[object Object]","str":"test"}', stringify(obj))
+})
+
+test('patternProperties should not change properties', (t) => {
+  t.plan(1)
+  const stringify = build({
+    title: 'patternProperties should not change properties',
+    type: 'object',
+    properties: {
+      foo: {
+        type: 'string'
+      }
+    },
+    patternProperties: {
+      foo: {
+        type: 'number'
+      }
+    }
+  })
+
+  const obj = { foo: '42', ofoo: 42 }
+  t.equal('{"ofoo":42,"foo":"42"}', stringify(obj))
+})
+
+test('patternProperties - string coerce', (t) => {
+  t.plan(1)
+  const stringify = build({
+    title: 'check string coerce',
+    type: 'object',
+    properties: {},
+    patternProperties: {
+      foo: {
+        type: 'string'
+      }
+    }
+  })
+
+  const obj = { foo: true, ofoo: 42, arrfoo: ['array', 'test'], objfoo: { a: 'world' } }
+  t.equal('{"foo":"true","ofoo":"42","arrfoo":"array,test","objfoo":"[object Object]"}', stringify(obj))
+})
+
+test('patternProperties - number coerce', (t) => {
+  t.plan(1)
+  const stringify = build({
+    title: 'check number coerce',
+    type: 'object',
+    properties: {},
+    patternProperties: {
+      foo: {
+        type: 'number'
+      }
+    }
+  })
+
+  const obj = { foo: true, ofoo: '42', xfoo: 'string', arrfoo: [1, 2], objfoo: { num: 42 } }
+  t.equal('{"foo":1,"ofoo":42,"xfoo":null,"arrfoo":null,"objfoo":null}', stringify(obj))
+})
+
+test('patternProperties - boolean coerce', (t) => {
+  t.plan(1)
+  const stringify = build({
+    title: 'check boolean coerce',
+    type: 'object',
+    properties: {},
+    patternProperties: {
+      foo: {
+        type: 'boolean'
+      }
+    }
+  })
+
+  const obj = { foo: 'true', ofoo: 0, arrfoo: [1, 2], objfoo: { a: true } }
+  t.equal('{"foo":true,"ofoo":false,"arrfoo":true,"objfoo":true}', stringify(obj))
+})
+
+test('patternProperties - object coerce', (t) => {
+  t.plan(1)
+  const stringify = build({
+    title: 'check object coerce',
+    type: 'object',
+    properties: {},
+    patternProperties: {
+      foo: {
+        type: 'object',
+        properties: {
+          answer: {
+            type: 'number'
+          }
+        }
+      }
+    }
+  })
+
+  const obj = { objfoo: { answer: 42 } }
+  t.equal('{"objfoo":{"answer":42}}', stringify(obj))
+})
+
+test('patternProperties - array coerce', (t) => {
+  t.plan(1)
+  const stringify = build({
+    title: 'check array coerce',
+    type: 'object',
+    properties: {},
+    patternProperties: {
+      foo: {
+        type: 'array',
+        items: {
+          type: 'string'
+        }
+      }
+    }
+  })
+
+  const obj = { foo: 'true', ofoo: 0, arrfoo: [1, 2], objfoo: { tyrion: 'lannister' } }
+  t.equal('{"foo":["t","r","u","e"],"ofoo":[],"arrfoo":["1","2"],"objfoo":[]}', stringify(obj))
+})
+
+test('patternProperties - throw on unknown type', (t) => {
+  t.plan(1)
+  const stringify = build({
+    title: 'check array coerce',
+    type: 'object',
+    properties: {},
+    patternProperties: {
+      foo: {
+        type: 'strangetype'
+      }
+    }
+  })
+
+  const obj = { foo: 'true', ofoo: 0, arrfoo: [1, 2], objfoo: { tyrion: 'lannister' } }
+  try {
+    stringify(obj)
+    t.fail()
+  } catch (e) {
+    t.pass()
+  }
+})