bfj 9.1.1 → 9.1.2

package/.eslintrc

@@ -145,7 +145,7 @@ rules:
   no-spaced-func: 2
   no-sparse-arrays: 2
   no-sync: 0
-  no-ternary: 1
+  no-ternary: 0
   no-this-before-super: 2
   no-throw-literal: 1
   no-trailing-spaces: 2

package/HISTORY.md

@@ -1,5 +1,17 @@
 # History
 
+## 9.1.2
+
+### Bug fixes
+
+* streamify: fix nonsense race condition mitigation (bcf35db58538b3e4feda31e4d0781ff16ee0d0a7)
+
+### Other changes
+
+* deps: upgrade `cross-spawn` to `7.0.6` (4a55a0f3e8a0a6eadc3f43bd3c0f33eedb0619a6)
+* eventify: remove redundant `async` (44d90b45f0f84423784ccd835dad20ca8209162b)
+* lint: stop warning on ternary operators (4cb552cd2b69b0432ace5f326b2804f57010e69f)
+
 ## 9.1.1
 
 ### Bug fixes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bfj",
-  "version": "9.1.1",
+  "version": "9.1.2",
   "description": "Big-friendly JSON. Asynchronous streaming functions for large JSON data sets.",
   "homepage": "https://gitlab.com/philbooth/bfj",
   "bugs": "https://gitlab.com/philbooth/bfj/issues",

package/src/eventify.js

@@ -209,7 +209,7 @@ function eventify (data, options = {}) {
     return datum > Number.NEGATIVE_INFINITY && datum < Number.POSITIVE_INFINITY
   }
 
-  async function yieldThenProceed (datum, resolve, reject) {
+  function yieldThenProceed (datum, resolve, reject) {
     setImmediate(async () => {
       try {
         resolve(await afterCoercion(await coerce(datum)))

package/src/streamify.js

@@ -50,6 +50,7 @@ function streamify (data, options = {}) {
     streamOptions = { highWaterMark }
   }
   const stream = new JsonStream(read, streamOptions)
+  const eventQueue = []
 
   let awaitPush = true
   let index = 0
@@ -58,7 +59,6 @@ function streamify (data, options = {}) {
   let isPaused = false
   let isProperty
   let length = 0
-  let mutex = Promise.resolve()
   let needsComma
 
   emitter.on(events.array, noRacing(array))
@@ -122,8 +122,17 @@ function streamify (data, options = {}) {
 
   function noRacing (handler) {
     return async (eventData) => {
-      await mutex
-      mutex = await handler(eventData)
+      let resolve
+
+      eventQueue.push(new Promise(res => resolve = res))
+
+      if (eventQueue.length > 1) {
+        await eventQueue[eventQueue.length - 2]
+        eventQueue.shift()
+      }
+
+      await handler(eventData)
+      resolve()
     }
   }
 

package/test/integration.js

@@ -445,6 +445,24 @@ suite('integration:', () => {
       })
     })
 
+    // https://gitlab.com/philbooth/bfj/-/issues/73
+    suite('issue #73:', () => {
+      const data = {
+        foo: 'bar',
+        wibble: 'blee',
+      }
+
+      let result
+
+      setup(async () => {
+        result = await  bfj.stringify(data, { space: 2 })
+      })
+
+      test('stringify result was correct', () => {
+        assert.strictEqual(result, JSON.stringify(data, null, 2))
+      })
+    })
+
     suite('write object:', () => {
       let failed, file, result
 
@@ -453,7 +471,8 @@ suite('integration:', () => {
         file = path.join(__dirname, 'data.json')
         return bfj.write(
           file,
-          { foo: [ 'b', 'a', 'r' ], baz: null, qux: 3.14159265359e42 }
+          { foo: [ 'b', 'a', 'r' ], bar: 'bar', blee: '', wibble: 'wibble', baz: null, qux: 3.14159265359e42 },
+          { bufferLength: 1 },
         )
         .then(() => {
           result = fs.readFileSync(file, { encoding: 'utf8' })
@@ -473,7 +492,7 @@ suite('integration:', () => {
       })
 
       test('result was correct', () => {
-        assert.strictEqual(result, '{"foo":["b","a","r"],"baz":null,"qux":3.14159265359e+42}')
+        assert.strictEqual(result, '{"foo":["b","a","r"],"bar":"bar","blee":"","wibble":"wibble","baz":null,"qux":3.14159265359e+42}')
       })
     })
   })

package/test/unit/eventify.js

@@ -694,6 +694,38 @@ suite('eventify:', () => {
       })
     })
 
+    suite('empty string:', () => {
+      setup(done => {
+        const emitter = eventify('')
+
+        Object.entries(events).forEach(([ key, value ]) => {
+          emitter.on(value, spooks.fn({
+            name: key,
+            log: log
+          }))
+        })
+
+        emitter.on(events.end, done)
+      })
+
+      test('string event occurred once', () => {
+        assert.strictEqual(log.counts.string, 1)
+      })
+
+      test('string event was dispatched correctly', () => {
+        assert.lengthOf(log.args.string[0], 1)
+        assert.strictEqual(log.args.string[0][0], '')
+      })
+
+      test('error event did not occur', () => {
+        assert.strictEqual(log.counts.error, 0)
+      })
+
+      test('dataError event did not occur', () => {
+        assert.strictEqual(log.counts.dataError, 0)
+      })
+    })
+
     suite('number:', () => {
       setup(done => {
         const emitter = eventify(42)

package/test/unit/streamify.js

@@ -720,6 +720,38 @@ suite('streamify:', () => {
           })
         })
       })
+
+      suite('concurrent events:', () => {
+        setup(() => {
+          log.args.JsonStream[0][0]()
+          const promises = []
+          promises.push(log.args.on[1][1]())
+          promises.push(log.args.on[2][1]('foo'))
+          promises.push(log.args.on[3][1]('bar'))
+          promises.push(log.args.on[2][1]('wibble'))
+          promises.push(log.args.on[3][1]('blee'))
+          promises.push(log.args.on[7][1]())
+          return Promise.all(promises)
+        })
+
+        test('stream.push was called 7 times', () => {
+          assert.strictEqual(log.counts.push, 7)
+        })
+
+        test('stream.push was called correctly', () => {
+          assert.strictEqual(log.args.push[0][0], '{')
+          assert.strictEqual(log.args.push[1][0], '"foo":')
+          assert.strictEqual(log.args.push[2][0], '"bar"')
+          assert.strictEqual(log.args.push[3][0], ',')
+          assert.strictEqual(log.args.push[4][0], '"wibble":')
+          assert.strictEqual(log.args.push[5][0], '"blee"')
+          assert.strictEqual(log.args.push[6][0], '}')
+        })
+
+        test('stream.emit was not called', () => {
+          assert.strictEqual(log.counts.emit, 0)
+        })
+      })
     })
 
     suite('streamify with space option:', () => {
@@ -950,6 +982,43 @@ suite('streamify:', () => {
         })
       })
 
+      suite('concurrent events:', () => {
+        setup(() => {
+          log.args.JsonStream[0][0]()
+          const promises = []
+          promises.push(log.args.on[1][1]())
+          promises.push(log.args.on[2][1]('foo'))
+          promises.push(log.args.on[3][1]('bar'))
+          promises.push(log.args.on[2][1]('wibble'))
+          promises.push(log.args.on[3][1]('blee'))
+          promises.push(log.args.on[7][1]())
+          return Promise.all(promises)
+        })
+
+        test('stream.push was called 12 times', () => {
+          assert.strictEqual(log.counts.push, 12)
+        })
+
+        test('stream.push was called correctly', () => {
+          assert.strictEqual(log.args.push[0][0], '{')
+          assert.strictEqual(log.args.push[1][0], '\n  ')
+          assert.strictEqual(log.args.push[2][0], '"foo":')
+          assert.strictEqual(log.args.push[3][0], ' ')
+          assert.strictEqual(log.args.push[4][0], '"bar"')
+          assert.strictEqual(log.args.push[5][0], ',')
+          assert.strictEqual(log.args.push[6][0], '\n  ')
+          assert.strictEqual(log.args.push[7][0], '"wibble":')
+          assert.strictEqual(log.args.push[8][0], ' ')
+          assert.strictEqual(log.args.push[9][0], '"blee"')
+          assert.strictEqual(log.args.push[10][0], '\n')
+          assert.strictEqual(log.args.push[11][0], '}')
+        })
+
+        test('stream.emit was not called', () => {
+          assert.strictEqual(log.counts.emit, 0)
+        })
+      })
+
       suite('read stream, end event:', () => {
         setup(() => {
           log.args.JsonStream[0][0]()