add .bytesRead property to varint.decode

README.md

@@ -6,7 +6,8 @@ encode whole numbers to an array of [protobuf-style varint bytes](https://develo
 var varint = require('varint')
 
 var bytes = varint.encode(300) // === [0xAC, 0x02]
-varint.decode(bytes) // [300, 2]
+varint.decode(bytes) // 300
+varint.decode.bytesRead // 2 (the last decode() call required 2 bytes)
 ```
 
 ## api
@@ -18,9 +19,20 @@ varint.decode(bytes) // [300, 2]
 encodes `num` into either the array given by `offset` or a new array at `offset`
 and returns that array filled with integers.
 
-### varint.decode(data[, offset=0]) -> [number, length]
+### varint.decode(data[, offset=0]) -> number
 
-decodes `data`, which can be either a buffer or array of integers, from position `offset` or default 0 and returns an array containing `[number, length]` where number is the original integer and length is the amount of bytes that were consumed in order to decode the number
+decodes `data`, which can be either a buffer or array of integers, from position `offset` or default 0 and returns the decoded original integer.
+
+### varint.decode.bytesRead
+
+if you also require the length (number of bytes) that were required to decode the integer you can access it via `varint.decode.bytesRead`. this is an integer property that will tell you the number of bytes that the last .decode() call had to use to decode.
+
+## usage notes
+
+if you are using this to decode buffers from a streaming source it's up to you to make sure that you send 'complete' buffers into `varint.decode`. the maximum number of bytes that varint will need to decode is 8, so all you have to do is make sure you are sending buffers that are at least 8 bytes long from the point at which you know a varint range begins.
+
+for example, if you are reading buffers from a `fs.createReadStream`,
+imagine the first buffer contains one full varint range and half of a second one, and the second buffer contains the second half of the second varint range. in order to be safe across the buffer boundaries you'd just have to make sure the buffer you give to `varint.decode` contains the full varint range (8 bytes), otherwise you'll get an error.
 
 # License
 

decode.js

@@ -18,5 +18,7 @@ function read(buf, offset) {
     shift += 7
   } while (b >= MSB)
   
-  return [res, counter - offset]
+  read.bytesRead = counter - offset
+  
+  return res
 }

index.js

@@ -1,4 +1,4 @@
 module.exports = {
-  encode: require('./encode.js'),
-  decode: require('./decode.js')
-}
+    encode: require('./encode.js')
+  , decode: require('./decode.js')
+}

test.js

@@ -1,5 +1,7 @@
 var varint = require('./index')
   , test = require('tape')
+  , decode = varint.decode
+  , encode = varint.encode
 
 test('fuzz test', function(assert) {
   var expect
@@ -7,10 +9,10 @@ test('fuzz test', function(assert) {
 
   for(var i = 0, len = 100; i < len; ++i) {
     expect = randint(0x7FFFFFFF)
-    encoded = varint.encode(expect)
-    var data = varint.decode(encoded)
-    assert.equal(expect, data[0], 'fuzz test: '+expect.toString())
-    assert.equal(data[1], encoded.length)
+    encoded = encode(expect)
+    var data = decode(encoded)
+    assert.equal(expect, data, 'fuzz test: ' + expect.toString())
+    assert.equal(decode.bytesRead, encoded.length)
   }
 
   assert.end()
@@ -20,16 +22,16 @@ test('test single byte works as expected', function(assert) {
   var buf = new Uint8Array(2)
   buf[0] = 172
   buf[1] = 2
-  var data = varint.decode(buf)
-  assert.equal(data[0], 300, 'should equal 300')
-  assert.equal(data[1], 2)
+  var data = decode(buf)
+  assert.equal(data, 300, 'should equal 300')
+  assert.equal(decode.bytesRead, 2)
   assert.end()
 })
 
 test('test encode works as expected', function(assert) {
   var out = []
 
-  assert.deepEqual(varint.encode(300), [0xAC, 0x02])
+  assert.deepEqual(encode(300), [0xAC, 0x02])
 
   assert.end()
 })
@@ -38,9 +40,9 @@ test('test decode single bytes', function(assert) {
   var expected = randint(parseInt('1111111', '2'))
   var buf = new Uint8Array(1)
   buf[0] = expected
-  var data = varint.decode(buf)
-  assert.equal(data[0], expected)
-  assert.equal(data[1], 1)
+  var data = decode(buf)
+  assert.equal(data, expected)
+  assert.equal(decode.bytesRead, 1)
   assert.end()
 })
 
@@ -49,21 +51,21 @@ test('test decode multiple bytes with zero', function(assert) {
   var buf = new Uint8Array(2)
   buf[0] = 128
   buf[1] = expected
-  var data = varint.decode(buf)
-  assert.equal(data[0], expected << 7)
-  assert.equal(data[1], 2)
+  var data = decode(buf)
+  assert.equal(data, expected << 7)
+  assert.equal(decode.bytesRead, 2)
   assert.end()
 })
 
 test('encode single byte', function(assert) {
   var expected = randint(parseInt('1111111', '2'))
-  assert.deepEqual(varint.encode(expected), [expected])
+  assert.deepEqual(encode(expected), [expected])
   assert.end()
 })
 
 test('encode multiple byte with zero first byte', function(assert) {
   var expected = 0x0F00
-  assert.deepEqual(varint.encode(expected), [0x80, 0x1E])
+  assert.deepEqual(encode(expected), [0x80, 0x1E])
   assert.end()
 })