protons 2.0.3 → 3.0.2

package/src/compile/index.js

@@ -1,165 +0,0 @@
-'use strict'
-
-const encodings = require('./encodings')
-const compileDecode = require('./decode')
-const compileEncode = require('./encode')
-const compileEncodingLength = require('./encoding-length')
-const varint = require('varint')
-
-const flatten = function (values) {
-  if (!values) return null
-  const result = {}
-  Object.keys(values).forEach(function (k) {
-    result[k] = values[k].value
-  })
-  return result
-}
-
-module.exports = function (schema, extraEncodings) {
-  const messages = {}
-  const enums = {}
-  const cache = {}
-
-  const visit = function (schema, prefix) {
-    if (schema.enums) {
-      schema.enums.forEach(function (e) {
-        e.id = prefix + (prefix ? '.' : '') + e.name
-        enums[e.id] = e
-        visit(e, e.id)
-      })
-    }
-    if (schema.messages) {
-      schema.messages.forEach(function (m) {
-        m.id = prefix + (prefix ? '.' : '') + m.name
-        messages[m.id] = m
-        m.fields.forEach(function (f) {
-          if (!f.map) return
-
-          const name = 'Map_' + f.map.from + '_' + f.map.to
-          const map = {
-            name: name,
-            enums: [],
-            messages: [],
-            fields: [{
-              name: 'key',
-              type: f.map.from,
-              tag: 1,
-              repeated: false,
-              required: true
-            }, {
-              name: 'value',
-              type: f.map.to,
-              tag: 2,
-              repeated: false,
-              required: false
-            }],
-            extensions: null,
-            id: prefix + (prefix ? '.' : '') + name
-          }
-
-          if (!messages[map.id]) {
-            messages[map.id] = map
-            schema.messages.push(map)
-          }
-          f.type = name
-          f.repeated = true
-        })
-        visit(m, m.id)
-      })
-    }
-  }
-
-  visit(schema, '')
-
-  const compileEnum = function (e) {
-    const values = Object.keys(e.values || []).map(function (k) {
-      return parseInt(e.values[k].value, 10)
-    })
-
-    const encode = function enumEncode (val, buf, view, offset) {
-      if (!values.length || values.indexOf(val) === -1) {
-        throw new Error('Invalid enum value: ' + val)
-      }
-      varint.encode(val, buf, offset)
-      enumEncode.bytes = varint.encode.bytes
-      return buf
-    }
-
-    const decode = function enumDecode (buf, view, offset) {
-      var val = varint.decode(buf, offset)
-      if (!values.length || values.indexOf(val) === -1) {
-        throw new Error('Invalid enum value: ' + val)
-      }
-      enumDecode.bytes = varint.decode.bytes
-      return val
-    }
-
-    return encodings.make(0, encode, decode, varint.encodingLength)
-  }
-
-  const compileMessage = function (m, exports) {
-    m.messages.forEach(function (nested) {
-      exports[nested.name] = resolve(nested.name, m.id)
-    })
-
-    m.enums.forEach(function (val) {
-      exports[val.name] = flatten(val.values)
-    })
-
-    exports.type = 2
-    exports.message = true
-    exports.name = m.name
-
-    const oneofs = {}
-
-    m.fields.forEach(function (f) {
-      if (!f.oneof) return
-      if (!oneofs[f.oneof]) oneofs[f.oneof] = []
-      oneofs[f.oneof].push(f.name)
-    })
-
-    const enc = m.fields.map(function (f) {
-      return resolve(f.type, m.id)
-    })
-
-    const encodingLength = compileEncodingLength(m, enc, oneofs)
-    const encode = compileEncode(m, resolve, enc, oneofs, encodingLength)
-    const decode = compileDecode(m, resolve, enc)
-
-    // end of compilation - return all the things
-
-    encode.bytes = decode.bytes = 0
-
-    exports.buffer = true
-    exports.encode = encode
-    exports.decode = decode
-    exports.encodingLength = encodingLength
-
-    return exports
-  }
-
-  const resolve = function (name, from, compile) {
-    if (extraEncodings && extraEncodings[name]) return extraEncodings[name]
-    if (encodings[name]) return encodings[name]
-
-    const m = (from ? from + '.' + name : name).split('.')
-      .map(function (part, i, list) {
-        return list.slice(0, i).concat(name).join('.')
-      })
-      .reverse()
-      .reduce(function (result, id) {
-        return result || messages[id] || enums[id]
-      }, null)
-
-    if (compile === false) return m
-    if (!m) throw new Error('Could not resolve ' + name)
-
-    if (m.values) return compileEnum(m)
-    const res = cache[m.id] || compileMessage(m, cache[m.id] = {})
-    return res
-  }
-
-  return (schema.enums || []).concat((schema.messages || []).map(function (message) {
-    return resolve(message.id)
-  }))
-}

package/src/compile/utils.js

@@ -1,5 +0,0 @@
-'use strict'
-
-exports.defined = function (val) {
-  return val !== null && val !== undefined && (typeof val !== 'number' || !isNaN(val))
-}

package/src/index.js

@@ -1,39 +0,0 @@
-'use strict'
-
-var schema = require('protocol-buffers-schema')
-var compile = require('./compile')
-
-var flatten = function (values) {
-  if (!values) return null
-  var result = {}
-  Object.keys(values).forEach(function (k) {
-    result[k] = values[k].value
-  })
-  return result
-}
-
-module.exports = function (proto, opts) {
-  if (!opts) opts = {}
-  if (!proto) throw new Error('Pass in a .proto string or a protobuf-schema parsed object')
-
-  var sch = (typeof proto === 'object' && !(proto instanceof Uint8Array)) ? proto : schema.parse(proto)
-
-  // to not make toString,toJSON enumarable we make a fire-and-forget prototype
-  var Messages = function () {
-    var self = this
-
-    compile(sch, opts.encodings || {}).forEach(function (m) {
-      self[m.name] = flatten(m.values) || m
-    })
-  }
-
-  Messages.prototype.toString = function () {
-    return schema.stringify(sch)
-  }
-
-  Messages.prototype.toJSON = function () {
-    return sch
-  }
-
-  return new Messages()
-}

package/test/basic.spec.js

@@ -1,109 +0,0 @@
-/* eslint-env mocha */
-
-'use strict'
-
-const { expect } = require('aegir/utils/chai')
-const protobufNpm = require('protocol-buffers')
-const protobuf = require('../src')
-const proto = require('./test.proto')
-const Basic = protobuf(proto).Basic
-const BasicNpm = protobufNpm(proto).Basic
-const { fromString: uint8ArrayFromString } = require('uint8arrays/from-string')
-const { toString: uint8ArrayToString } = require('uint8arrays/to-string')
-
-describe('basic', () => {
-  it('should encode basic object', () => {
-    const first = {
-      num: 1,
-      payload: uint8ArrayFromString('lol')
-    }
-
-    const b1 = Basic.encode(first)
-
-    const bn1 = BasicNpm.encode({
-      ...first,
-      payload: 'lol' // old version does not support Uint8Arrays
-    })
-
-    expect(uint8ArrayToString(b1, 'base16')).to.equal(uint8ArrayToString(bn1, 'base16'))
-
-    const b2 = Basic.encode({
-      num: 1,
-      payload: uint8ArrayFromString('lol'),
-      meeeh: 42
-    })
-
-    const b3 = Basic.encode({
-      num: 1,
-      payload: uint8ArrayFromString('lol'),
-      meeeh: 42
-    })
-
-    expect(b2).to.deep.equal(b1)
-    expect(b3).to.deep.equal(b1)
-  })
-
-  it('should encode and decode basic object', () => {
-    const b1 = Basic.encode({
-      num: 1,
-      payload: uint8ArrayFromString('lol')
-    })
-
-    const o1 = Basic.decode(b1)
-
-    expect(o1).to.have.property('num', 1)
-    expect(o1).to.have.deep.property('payload', uint8ArrayFromString('lol'))
-
-    const b2 = Basic.encode({
-      num: 1,
-      payload: uint8ArrayFromString('lol'),
-      meeeh: 42
-    })
-
-    const o2 = Basic.decode(b2)
-
-    expect(o2).to.deep.equal(o1)
-  })
-
-  it('should add basic accessors', () => {
-    const b1 = Basic.encode({
-      num: 1,
-      payload: uint8ArrayFromString('lol')
-    })
-
-    const o1 = Basic.decode(b1)
-
-    expect(o1).to.have.property('hasNum').that.is.a('function')
-    expect(o1.hasNum()).to.be.true()
-
-    expect(o1).to.have.property('setNum').that.is.a('function')
-    o1.setNum(5)
-
-    expect(o1).to.have.property('getNum').that.is.a('function')
-    expect(o1.getNum(5)).to.equal(5)
-
-    expect(o1).to.have.property('clearNum').that.is.a('function')
-    o1.clearNum()
-
-    expect(o1.getNum(5)).to.be.undefined()
-
-    const methods = Object.keys(o1)
-
-    expect(methods).to.not.include('getNum')
-    expect(methods).to.not.include('setNum')
-    expect(methods).to.not.include('hasNum')
-    expect(methods).to.not.include('clearNum')
-  })
-
-  it('should encode and decode floats in a basic object', () => {
-    const b1 = Basic.encode({
-      num: 1.1,
-      payload: uint8ArrayFromString('lol')
-    })
-
-    const o1 = Basic.decode(b1)
-
-    expect(o1).to.have.property('num', 1.1)
-    expect(o1).to.have.deep.property('payload', uint8ArrayFromString('lol'))
-  })
-})

package/test/booleans.spec.js

@@ -1,37 +0,0 @@
-/* eslint-env mocha */
-
-'use strict'
-
-const { expect } = require('aegir/utils/chai')
-const protobuf = require('../src')
-const proto = require('./test.proto')
-const Booleans = protobuf(proto).Booleans
-
-describe('booleans', () => {
-  it('should encode and decode booleans', () => {
-    const b1 = Booleans.encode({
-      bool1: true,
-      bool2: false
-    })
-
-    const o1 = Booleans.decode(b1)
-
-    expect(o1).to.deep.equal({
-      bool1: true,
-      bool2: false
-    })
-  })
-
-  it('should encode and decode optional booleans', () => {
-    const b1 = Booleans.encode({
-      bool1: true
-    })
-    const o1 = Booleans.decode(b1)
-
-    expect(o1).to.deep.equal({
-      bool1: true,
-      bool2: false
-    })
-    expect(o1.hasBool2()).to.be.false()
-  })
-})

package/test/bytes.spec.js

@@ -1,36 +0,0 @@
-/* eslint-env mocha */
-
-'use strict'
-
-const { expect } = require('aegir/utils/chai')
-const protobuf = require('../src')
-const Bytes = protobuf(require('./test.proto')).Bytes
-
-describe('bytes', () => {
-  it('should encode and decode bytes', () => {
-    const b1 = Bytes.encode({
-      req: Uint8Array.from([0, 1, 2, 3]),
-      opt: Uint8Array.from([4, 5, 6, 7])
-    })
-
-    const o1 = Bytes.decode(b1)
-
-    expect(o1).to.deep.equal({
-      req: Uint8Array.from([0, 1, 2, 3]),
-      opt: Uint8Array.from([4, 5, 6, 7])
-    })
-  })
-
-  it('should encode and decode optional bytes', () => {
-    const b1 = Bytes.encode({
-      req: Uint8Array.from([0, 1, 2, 3])
-    })
-    const o1 = Bytes.decode(b1)
-
-    expect(o1).to.deep.equal({
-      req: Uint8Array.from([0, 1, 2, 3]),
-      opt: null
-    })
-    expect(o1.hasOpt()).to.be.false()
-  })
-})

package/test/corrupted.spec.js

@@ -1,50 +0,0 @@
-/* eslint-env mocha */
-
-'use strict'
-
-const { expect } = require('aegir/utils/chai')
-const { fromString: uint8ArrayFromString } = require('uint8arrays/from-string')
-const protobuf = require('../src')
-
-const protoStr = 'enum AbcType {\n' +
-  '  IGNORE                 =  0;\n' +
-  '  ACK_CONFIRMATION_TOKEN =  1;\n' +
-  '}\n' +
-  'message AbcAcknowledgeConfirmationToken { // 0x01\n' +
-  '  optional uint64 confirmation_token = 1;\n' +
-  '  extensions 1000 to max;\n' +
-  '}\n' +
-  'message ABC {\n' +
-  '  required AbcType type = 9;\n' +
-  '  required uint32 api_version = 8;\n' +
-  '  optional AbcAcknowledgeConfirmationToken ack_confirmation_token = 1;\n' +
-  '  extensions 1000 to max;\n' +
-  '}\n' +
-  'message Open {\n' +
-  '  required bytes feed = 1;\n' +
-  '  required bytes nonce = 2;\n' +
-  '}'
-
-const messages = protobuf(protoStr)
-
-describe('corrupted', () => {
-  it('should fail to decode an invalid message', () => {
-    expect(() => {
-      messages.ABC.decode(Uint8Array.from([8, 182, 168, 235, 144, 178, 41]))
-    }).to.throw(/not valid/)
-  })
-
-  it('should fail to decode non-byte arrays', () => {
-    expect(() => {
-      messages.ABC.decode({})
-    }).to.throw(/not valid/)
-  })
-
-  it('should fail to decode a base16 message', () => {
-    const buf = uint8ArrayFromString('cec1', 'base16')
-
-    expect(() => {
-      messages.Open.decode(buf)
-    }).to.throw(/Could not decode varint/)
-  })
-})

package/test/custom-types.spec.js

@@ -1,55 +0,0 @@
-/* eslint-env mocha */
-
-'use strict'
-
-const { expect } = require('aegir/utils/chai')
-const protobuf = require('../src')
-const CustomType = protobuf(require('./test.proto')).CustomType
-
-describe('custom types', () => {
-  it('should encode and decode custom types', () => {
-    var b1 = CustomType.encode({
-      req: {
-        num: 5,
-        payload: Uint8Array.from([])
-      },
-      opt: {
-        num: 6,
-        payload: Uint8Array.from([])
-      }
-    })
-
-    var o1 = CustomType.decode(b1)
-
-    expect(o1).to.deep.equal({
-      req: {
-        num: 5,
-        payload: Uint8Array.from([])
-      },
-      opt: {
-        num: 6,
-        payload: Uint8Array.from([])
-      }
-    })
-  })
-
-  it('should encode and decode custom types with optional fields', () => {
-    var b1 = CustomType.encode({
-      req: {
-        num: 5,
-        payload: Uint8Array.from([])
-      }
-    })
-
-    var o1 = CustomType.decode(b1)
-
-    expect(o1).to.deep.equal({
-      req: {
-        num: 5,
-        payload: Uint8Array.from([])
-      },
-      opt: null
-    })
-    expect(o1.hasOpt()).to.be.false()
-  })
-})

package/test/defaults.spec.js

@@ -1,44 +0,0 @@
-/* eslint-env mocha */
-
-'use strict'
-
-const { expect } = require('aegir/utils/chai')
-const protobuf = require('../src')
-const Defaults = protobuf(require('./test.proto')).Defaults
-
-describe('default', () => {
-  it('should decode with defaults', () => {
-    const o1 = Defaults.decode(new Uint8Array()) // everything default
-
-    const b2 = Defaults.encode({
-      num: 10,
-      foos: [1]
-    })
-
-    const b3 = Defaults.encode({
-      num: 10,
-      foo2: 2
-    })
-
-    expect(Defaults.decode(b3)).to.deep.equal({
-      num: 10,
-      foo1: 2,
-      foo2: 2,
-      foos: []
-    })
-
-    expect(o1).to.deep.equal({
-      num: 42,
-      foo1: 2,
-      foo2: 1,
-      foos: []
-    })
-
-    expect(Defaults.decode(b2)).to.deep.equal({
-      num: 10,
-      foo1: 2,
-      foo2: 1,
-      foos: [1]
-    })
-  })
-})

package/test/enums.spec.js

@@ -1,21 +0,0 @@
-/* eslint-env mocha */
-
-'use strict'
-
-const { expect } = require('aegir/utils/chai')
-const protobuf = require('../src')
-const messages = protobuf(require('./test.proto'))
-
-describe('enums', () => {
-  it('should encode and decode enums', () => {
-    const e = messages.FOO
-
-    expect(e).to.deep.equal({ A: 1, B: 2 })
-  })
-
-  it('should encode and decode hex enums', () => {
-    const e = messages.FOO_HEX
-
-    expect(e).to.deep.equal({ A: 1, B: 2 })
-  })
-})

package/test/float.spec.js

@@ -1,28 +0,0 @@
-/* eslint-env mocha */
-
-'use strict'
-
-const { expect } = require('aegir/utils/chai')
-const protobuf = require('../src')
-const Float = protobuf(require('./test.proto')).Float
-
-describe('floats', () => {
-  it('should encode and decode floats', () => {
-    const arr = new Float32Array(3)
-    arr[0] = 1.1
-    arr[1] = 0
-    arr[2] = -2.3
-
-    const obj = {
-      float1: arr[0],
-      float2: arr[1],
-      float3: arr[2]
-    }
-
-    const b1 = Float.encode(obj)
-
-    const o1 = Float.decode(b1)
-
-    expect(o1).to.deep.equal(obj)
-  })
-})

package/test/integers.spec.js

@@ -1,72 +0,0 @@
-/* eslint-env mocha */
-
-'use strict'
-
-const { expect } = require('aegir/utils/chai')
-const protobuf = require('../src')
-const Integers = protobuf(require('./test.proto')).Integers
-
-describe('integers', () => {
-  it('should encode and decode integers', () => {
-    const b1 = Integers.encode({
-      sint32: 1,
-      sint64: 2,
-      int32: 3,
-      uint32: 4,
-      int64: 5,
-      fixed32: 6
-    })
-
-    const o1 = Integers.decode(b1)
-
-    expect(o1).to.deep.equal({
-      sint32: 1,
-      sint64: 2,
-      int32: 3,
-      uint32: 4,
-      int64: 5,
-      fixed32: 6
-    })
-  })
-
-  it('should encode and decode negative integers', () => {
-    const b1 = Integers.encode({
-      sint32: -1,
-      sint64: -2,
-      int32: -3,
-      uint32: 0,
-      int64: -1 * Math.pow(2, 52) - 5,
-      fixed32: 0
-    })
-
-    const o1 = Integers.decode(b1)
-
-    expect(o1).to.deep.equal({
-      sint32: -1,
-      sint64: -2,
-      int32: -3,
-      uint32: 0,
-      int64: -1 * Math.pow(2, 52) - 5,
-      fixed32: 0
-    })
-  })
-
-  it('should encode and decode optional integers', () => {
-    const b1 = Integers.encode({
-      sint32: null
-    })
-    const b2 = Integers.encode({
-      sint32: 0
-    })
-
-    // sint32 is optional, verify that setting it to null does not
-    // cause a value to be written into the encoded buffer
-    expect(b1.length).to.be.lessThan(b2.length)
-
-    const o1 = Integers.decode(b1)
-    expect(o1.hasSint32()).to.be.false()
-
-    const o2 = Integers.decode(b2)
-    expect(o2.sint32).to.equal(0)
-  })
-})

package/test/map.spec.js

@@ -1,35 +0,0 @@
-/* eslint-env mocha */
-
-'use strict'
-
-const { expect } = require('aegir/utils/chai')
-const protobuf = require('../src')
-const Map = protobuf(require('./test.proto')).Map
-
-describe('maps', () => {
-  it('should encode and decode maps', () => {
-    const b1 = Map.encode({
-      foo: {
-        hello: 'world'
-      }
-    })
-
-    const o1 = Map.decode(b1)
-
-    expect(o1).to.have.deep.property('foo', { hello: 'world' })
-  })
-
-  it('should encode and decode maps with multiple fields', () => {
-    const doc = {
-      foo: {
-        hello: 'world',
-        hi: 'verden'
-      }
-    }
-
-    const b2 = Map.encode(doc)
-    const o2 = Map.decode(b2)
-
-    expect(o2).to.deep.equal(doc)
-  })
-})