aolog - npm Package Compare versions

Comparing version 3.2.0 to 3.2.1

index.js

@@ -34,3 +34,2 @@ 'use strict'
         var self = this
-
         restore(self.ref.Hash, function (err, res) {
@@ -136,3 +135,3 @@ if (err) return cb(err)
         var count = 0
-        for (var i = 0 ; i < idx ; i++ ) {
+        for (var i = 0 ; i < idx ; i++) {
           count += this.elements[i].count
@@ -231,7 +230,7 @@ }
 
-              cb(null, { value: new Finger(newelements)} )
+              cb(null, { value: new Finger(newelements)})
             })
           } else {
             newelements[2] = res.value
-            cb(null, { value: new Finger(newelements)} )
+            cb(null, { value: new Finger(newelements)})
           }
@@ -250,3 +249,3 @@ })
         var count = 0
-        for (var i = 0 ; i < idx ; i++ ) {
+        for (var i = 0 ; i < idx ; i++) {
           count += this.elements[i].count
@@ -388,6 +387,8 @@ }
           } else if (res.restored) {
-            stack[0].obj = res.restored
+            stack[0] = { obj: res.restored,
+                         idx: reverse ? res.restored.children - 1 : 0 }
             self.next(cb)
           } else if (typeof res.element !== 'undefined') {
             var index = offsetFromStack(stack)
+
             reverse ? stack[0].idx-- : stack[0].idx++
@@ -539,3 +540,3 @@ cb(null, {
     _.forEach(filter, function (value, key) {
-      var regexp = new RegExp('\\b' + value + '\\b', "i")
+      var regexp = new RegExp('\\b' + value + '\\b', 'i')
       if (typeof element[key] !== 'string' ||
@@ -542,0 +543,0 @@ !element[key].match(regexp)) {

package.json

 {
   "name": "aolog",
-  "version": "3.2.0",
+  "version": "3.2.1",
   "description": "Append only log",
@@ -13,3 +13,3 @@ "main": "index.js",
   "scripts": {
-    "build": "./node_modules/.bin/browserify -s AOlog -e ./index.js > aolog.js"
+    "build": "./node_modules/.bin/browserify -s AOlog -e ./index.js > dist/aolog.js"
   },
@@ -16,0 +16,0 @@ "devDependencies": {

test/test.js

 'use strict'
 
 var assert = require('assert')
-var BUCKET_SIZE = 4
+var BUCKET_SIZE = 2
 var ipfs = require('ipfs-api')()
@@ -34,3 +34,2 @@ var aolog = require('../index.js')(ipfs, BUCKET_SIZE)
 
-
 /* global describe, it, before */
@@ -138,3 +137,3 @@
 
-    var SIZE = BUCKET_SIZE + 1
+    var SIZE = BUCKET_SIZE * 8
 
@@ -462,3 +461,3 @@ var log
                  function (i) {
-                   return { is: "haystrand #" + i }
+                   return { is: 'haystrand #' + i }
                  },
@@ -475,3 +474,3 @@ function (err, res) {
         _.map(range(0, HAYSIZE), function (i) {
-          var iter = log.iterator({
+          log.iterator({
             filter: {
@@ -483,3 +482,3 @@ is: 'hAyStRaNd #' + i
             results[i] = res
-            if (count++ == HAYSIZE - 1) done()
+            if (count++ === HAYSIZE - 1) done()
           })
@@ -493,3 +492,3 @@ })
           assert.equal(results[i][0].element.is,
-                       "haystrand #" + i)
+                       'haystrand #' + i)
         }
@@ -499,3 +498,3 @@ })
 
-    describe("backward search", function () {
+    describe('backward search', function () {
       var log
@@ -508,3 +507,3 @@ var results = []
                  function (i) {
-                   return { is: "haystrand #" + i }
+                   return { is: 'haystrand #' + i }
                  },
@@ -521,3 +520,3 @@ function (err, res) {
         _.map(range(0, HAYSIZE), function (i) {
-          var iter = log.iterator({
+          log.iterator({
             filter: {
@@ -530,3 +529,3 @@ is: 'hAyStRaNd #' + i
             results[i] = res
-            if (++count == HAYSIZE) done()
+            if (++count === HAYSIZE) done()
           })
@@ -541,3 +540,3 @@ })
           assert.equal(results[i][0].element.is,
-                       "haystrand #" + i,
+                       'haystrand #' + i,
                        'right strand')
@@ -572,5 +571,6 @@ }
                current.iterator().all(function (err, res) {
+                 if (err) throw err
                  assert.deepEqual(range(0, i),
                                   _.map(res, function (x) { return x.index }))
-                 if (++count == SIZE) done()
+                 if (++count === SIZE) done()
                })
@@ -590,5 +590,6 @@ return i
                current.iterator({ offset: offset }).all(function (err, res) {
+                 if (err) throw err
                  assert.deepEqual(range(offset, i),
                                   _.map(res, function (x) { return x.index }))
-                 if (++count == SIZE) done()
+                 if (++count === SIZE) done()
                })
@@ -603,3 +604,2 @@ return i
   it('should have the correct reverse indicies', function (done) {
-    var count = 0
     add_many(aolog.empty(), SIZE,
@@ -778,3 +778,3 @@ function (i, current) {
     var log
-    var SIZE = BUCKET_SIZE * 32 + 1
+    var SIZE = BUCKET_SIZE * 10
 
@@ -942,2 +942,358 @@ before(function (done) {
   })
+
+  var persist_restore = function (log, cb) {
+    log.persist(function (err, res) {
+      if (err) throw err
+      aolog.restore(res.Hash, cb)
+    })
+  }
+
+  describe('persisted finger iterator', function () {
+    var SIZE = BUCKET_SIZE + 1
+
+    var log
+    var expected = []
+
+    before(function (done) {
+      add_many(aolog.empty(), SIZE,
+               function (i) {
+                 expected.push(i)
+                 return i
+               },
+               function (err, res) {
+                 if (err) throw err
+                 persist_restore(res, function (err, res) {
+                   if (err) throw err
+                   log = res
+                   done()
+                 })
+               })
+    })
+
+    var result = []
+
+    before(function (done) {
+      var iter = log.iterator()
+      async.forever(function (next) {
+        iter.next(function (err, res) {
+          if (err) throw (err)
+          if (res.eof) return next(1)
+          result.push(res.element)
+          next()
+        })
+      }, function () { done() })
+    })
+
+    it('should have gotten the right elements', function () {
+      assert.deepEqual(expected, result)
+    })
+
+    var nr = Math.floor(SIZE / 3)
+    var resultPart = []
+
+    before(function (done) {
+      var iter = log.iterator()
+
+      iter.take(nr, function (err, array) {
+        if (err) throw err
+        resultPart = _.map(array, function (x) { return x.element })
+        done()
+      })
+    })
+
+    it('should have taken ' + nr + ' of ' + SIZE + ' elements', function () {
+      assert.deepEqual(resultPart, expected.slice(0, nr))
+    })
+
+    var resultTakeMore
+
+    before(function (done) {
+      var iter = log.iterator()
+
+      iter.take(SIZE * 2, function (err, array) {
+        if (err) throw err
+        resultTakeMore = _.map(array, function (x) { return x.element })
+        done()
+      })
+
+    })
+
+    it('should have stopped at ' + SIZE + ' elements', function () {
+      assert.deepEqual(resultTakeMore, expected)
+    })
+
+    var resultAll = []
+    before(function (done) {
+      var iter = log.iterator()
+
+      iter.all(function (err, array) {
+        if (err) throw err
+        resultAll = _.map(array, function (x) { return x.element })
+        done()
+      })
+
+    })
+
+    it('should have taken all elements', function () {
+      assert.deepEqual(resultAll, expected)
+    })
+
+    var reference = []
+
+    before(function (done) {
+      add_many(aolog.empty(), SIZE,
+               function (i) {
+                 reference.push(i)
+                 return i
+               },
+               function (err, res) {
+                 if (err) throw err
+                 persist_restore(res, function (err, res) {
+                   if (err) throw err
+                   log = res
+                   done()
+                 })
+               })
+    })
+
+    it('should take all from all offsets', function (done) {
+      var count = 0
+
+      _.map(range(0, SIZE), function (ofs) {
+        var iter = log.iterator({offset: ofs})
+        count++
+        iter.all(function (err, array) {
+          if (err) throw err
+          assert.deepEqual(_.map(array, function (x) { return x.element }),
+                           reference.slice(ofs))
+          if (!--count) done()
+        })
+      })
+    })
+
+    it('should take 1 from all offsets', function (done) {
+      var count = 0
+      _.map(range(0, SIZE), function (ofs) {
+        var iter = log.iterator({offset: ofs})
+        iter.next(function (err, res) {
+          if (err) throw err
+          assert.deepEqual(res.element, reference[ofs])
+          if (++count === SIZE) done()
+        })
+      })
+    })
+
+    it('should take all from all offsets in reverse2', function (done) {
+      var count = 0
+
+      _.map(range(0, SIZE), function (ofs) {
+        var iter = log.iterator({offset: ofs, reverse: true})
+        count++
+        iter.all(function (err, array) {
+          if (err) throw err
+          assert.deepEqual(_.map(array, function (x) { return x.element }),
+                           reference.slice(0, ofs + 1).reverse())
+          if (!--count) done()
+        })
+      })
+    })
+
+    it('should take 1 from all offsets in reverse', function (done) {
+      var count = 0
+      _.map(range(0, SIZE), function (ofs) {
+        var iter = log.iterator({offset: ofs, reverse: true})
+        iter.next(function (err, res) {
+          if (err) throw err
+          assert.deepEqual(res.element, reference[ofs])
+          if (++count === SIZE) done()
+        })
+      })
+    })
+  })
+
+  describe('persisted finger iterator reverse', function () {
+    var log
+    var SIZE = BUCKET_SIZE * 5
+    var expected = []
+
+    before(function (done) {
+      add_many(aolog.empty(), SIZE,
+               function (i) {
+                 expected.unshift(i)
+                 return i
+               },
+               function (err, res) {
+                 if (err) throw err
+                 persist_restore(res, function (err, res) {
+                   if (err) throw err
+                   log = res
+                   done()
+                 })
+               })
+    })
+
+    var result = []
+
+    it('should have gotten the right elements', function (done) {
+      var iter = log.iterator({reverse: true})
+
+      async.forever(function (next) {
+        iter.next(function (err, res) {
+          if (err) throw (err)
+          if (res.eof) return next(1)
+
+          result.push(res.element)
+          next()
+        })
+      }, function () {
+        assert.deepEqual(expected, result)
+        done()
+      })
+    })
+
+    var nr = Math.floor(SIZE / 3)
+    var resultPart = []
+
+    before(function (done) {
+      var iter = log.iterator({reverse: true})
+
+      iter.take(nr, function (err, array) {
+        if (err) throw err
+        resultPart = _.map(array, function (x) { return x.element })
+        done()
+      })
+    })
+
+    it('should have taken ' + nr + ' of ' + SIZE + ' elements', function () {
+      assert.deepEqual(resultPart, expected.slice(0, nr))
+    })
+
+    var resultTakeMore
+
+    before(function (done) {
+      var iter = log.iterator({reverse: true})
+
+      iter.take(SIZE * 2, function (err, array) {
+        if (err) throw err
+        resultTakeMore = _.map(array, function (x) { return x.element })
+        done()
+      })
+
+    })
+
+    it('should have stopped at ' + SIZE + ' elements', function () {
+      assert.deepEqual(resultTakeMore, expected)
+    })
+
+    var resultAll = []
+    before(function (done) {
+      var iter = log.iterator({reverse: true})
+
+      iter.all(function (err, array) {
+        if (err) throw err
+        resultAll = _.map(array, function (x) { return x.element })
+        done()
+      })
+
+    })
+
+    it('should have taken all elements', function () {
+      assert.deepEqual(resultAll, expected)
+    })
+  })
+
+  describe('persistant haystack', function () {
+    var HAYSIZE = 20
+
+    describe('forward search', function () {
+      var log
+      var results = []
+
+      before(function (done) {
+        this.timeout(40000)
+        add_many(aolog.empty(), HAYSIZE,
+                 function (i) {
+                   return { is: 'haystrand #' + i }
+                 },
+                 function (err, res) {
+                   if (err) throw err
+                   persist_restore(res, function (err, res) {
+                     if (err) throw err
+                     log = res
+                     done()
+                   })
+                 })
+      })
+
+      before(function (done) {
+        var count = 0
+        _.map(range(0, HAYSIZE), function (i) {
+          log.iterator({
+            filter: {
+              is: 'hAyStRaNd #' + i
+            }
+          }).all(function (err, res) {
+            if (err) throw err
+            results[i] = res
+            if (count++ === HAYSIZE - 1) done()
+          })
+        })
+      })
+
+      it('should have found all the haystrands', function () {
+        for (var i = 0 ; i < HAYSIZE ; i++) {
+          assert.equal(results[i].length, 1)
+          assert.equal(results[i][0].element.is,
+                       'haystrand #' + i)
+        }
+      })
+    })
+
+    describe('backward search', function () {
+      var log
+      var results = []
+
+      before(function (done) {
+        this.timeout(40000)
+        add_many(aolog.empty(), HAYSIZE,
+                 function (i) {
+                   return { is: 'haystrand #' + i }
+                 },
+                 function (err, res) {
+                   if (err) throw err
+                   persist_restore(res, function (err, res) {
+                     if (err) throw err
+                     log = res
+                     done()
+                   })
+                 })
+      })
+
+      before(function (done) {
+        var count = 0
+        _.map(range(0, HAYSIZE), function (i) {
+          log.iterator({
+            filter: {
+              is: 'hAyStRaNd #' + i
+            },
+            reverse: true
+          }).all(function (err, res) {
+            if (err) throw err
+            results[i] = res
+            if (++count === HAYSIZE) done()
+          })
+        })
+      })
+
+      it('should have found all the haystrands', function () {
+        for (var i = 0 ; i < HAYSIZE ; i++) {
+          assert.equal(results[i].length, 1, 'right length')
+          assert.equal(results[i][0].index, i, 'right index')
+          assert.equal(results[i][0].element.is,
+                       'haystrand #' + i,
+                       'right strand')
+        }
+      })
+    })
+  })
 })

New alerts

Major refactor

Supply chain risk

Package has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

777167

increased by1.25%

Lines of code

22323

increased by1.38%

Worsened metrics

Number of medium supply chain risk alerts

2

increased by100%

No dependency changes