552264378

Build Type

github

Committed by GitHub

Commit Message

<a href="https://github.com/hildjj/node-cbor/commit/<a class=hub.com/hildjj/node-cbor/commit/d9f11cc9cd550e067d3b83feb42089749874a6c6">d9f11cc9c<a href="https://github.com/hildjj/node-cbor/commit/d9f11cc9cd550e067d3b83feb42089749874a6c6">">Merge </a><a class="double-link" href="https://github.com/hildjj/node-cbor/commit/<a class="double-link" href="https://github.com/hildjj/node-cbor/commit/b3ae5b7dfd01e6422da7fbc93bcf76792d822ebe">b3ae5b7df</a>">b3ae5b7df</a><a href="https://github.com/hildjj/node-cbor/commit/d9f11cc9cd550e067d3b83feb42089749874a6c6"> into dc25e8a4b">dc25e8a4b</a>

Pull Request Pull Request #133: Require buffer

Run Details

865 of 867 branches covered (99.77%)

142 of 146 new or added lines in 9 files covered. (97.26%)

1398 of 1402 relevant lines covered (99.71%)

22521.7 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

97.52

/packages/cbor/lib/tagged.js

'use strict'

const constants = require('./constants')
const utils = require('./utils')
const { Buffer } = require('buffer')

function setBuffersToJSON(obj, fn) {
  // The data item tagged can be a byte string or any other data item.  In the
  // latter case, the tag applies to all of the byte string data items
  // contained in the data item, except for those contained in a nested data
  // item tagged with an expected conversion.
  if (Buffer.isBuffer(obj)) {
    obj.toJSON = fn
  } else if (Array.isArray(obj)) {
    for (const v of obj) {
      setBuffersToJSON(v, fn)
    }
  } else if (obj && (typeof obj === 'object')) {
    // ffs, complexity in the protocol.
    if (!(obj instanceof Tagged) || (obj.tag < 21) || (obj.tag > 23)) {
      for (const v of Object.values(obj)) {
        setBuffersToJSON(v, fn)
      }
    }
  }
}

const INTERNAL_JSON = Symbol('INTERNAL_JSON')
/**
 * A CBOR tagged item, where the tag does not have semantics specified at the
 * moment, or those semantics threw an error during parsing. Typically this will
 * be an extension point you're not yet expecting.
 */
class Tagged {

  /**
   * Creates an instance of Tagged.
   *
   * @param {number} tag - the number of the tag
   * @param {any} value - the value inside the tag
   * @param {Error} [err] - the error that was thrown parsing the tag, or null
   */
  constructor(tag, value, err) {
    this.tag = tag
    this.value = value
    this.err = err
    if (typeof this.tag !== 'number') {
      throw new Error('Invalid tag type (' + (typeof this.tag) + ')')
    }
    if ((this.tag < 0) || ((this.tag | 0) !== this.tag)) {
      throw new Error('Tag must be a positive integer: ' + this.tag)
    }
  }

  toJSON() {
    if (this[INTERNAL_JSON]) {
      return this[INTERNAL_JSON]()
    }
    const ret = {
      tag: this.tag,
      value: this.value
    }
    if (this.err) {
      ret.err = this.err
    }
    return ret
  }

  /**
   * Convert to a String
   *
   * @returns {string} string of the form '1(2)'
   */
  toString() {
    return `${this.tag}(${JSON.stringify(this.value)})`
  }

  /**
   * Push the simple value onto the CBOR stream
   *
   * @param {Object} gen The generator to push onto
   */
  encodeCBOR(gen) {
    gen._pushTag(this.tag)
    return gen.pushAny(this.value)
  }

  /**
   * If we have a converter for this type, do the conversion.  Some converters
   * are built-in.  Additional ones can be passed in.  If you want to remove
   * a built-in converter, pass a converter in whose value is 'null' instead
   * of a function.
   *
   * @param {Object} converters - keys in the object are a tag number, the value
   *   is a function that takes the decoded CBOR and returns a JavaScript value
   *   of the appropriate type.  Throw an exception in the function on errors.
   * @returns {any} - the converted item
   */
  convert(converters) {
    let f = converters != null ? converters[this.tag] : void 0
    if (typeof f !== 'function') {
      f = Tagged['_tag_' + this.tag]
      if (typeof f !== 'function') {
        return this
      }
    }
    try {
      return f.call(this, this.value)
    } catch (error) {
      if (error && error.message) {
        this.err = error.message
      } else {
        this.err = error
      }
      return this
    }
  }

  // Standard date/time string; see Section 3.4.1
  static _tag_0(v) {
    return new Date(v)
  }

  // Epoch-based date/time; see Section 3.4.2
  static _tag_1(v) {
    return new Date(v * 1000)
  }

  // Positive bignum; see Section 3.4.3
  static _tag_2(v) {
    // (note: replaced by bigint version in decoder.js when bigint on)
    return utils.bufferToBignumber(v) // throws if no BigNumber
  }

  // Negative bignum; see Section 3.4.3
  static _tag_3(v) {
    // (note: replaced by bigint version in decoder.js when bigint on)
    const pos = utils.bufferToBignumber(v) // throws if no BigNumber
    return constants.BN.MINUS_ONE.minus(pos)
  }

  // Decimal fraction; see Section 3.4.4
  static _tag_4(v) {
    if (!constants.BigNumber) {
      throw new Error('No bignumber.js')
    }
    return new constants.BigNumber(v[1]).shiftedBy(v[0])
  }

  // Bigfloat; see Section 3.4.4
  static _tag_5(v) {
    if (!constants.BigNumber) {
      throw new Error('No bignumber.js')
    }
    return constants.BN.TWO.pow(v[0]).times(v[1])
  }

  // Expected conversion to base64url encoding; see Section 3.4.5.2
  static _tag_21(v) {
    if (Buffer.isBuffer(v)) {
      this[INTERNAL_JSON] = () => utils.base64url(v)
    } else {
      setBuffersToJSON(v, function() { // no =>, honor `this`
        return utils.base64url(this)
      })
    }
    return this
  }

  // Expected conversion to base64 encoding; see Section 3.4.5.2
  static _tag_22(v) {
    if (Buffer.isBuffer(v)) {
      this[INTERNAL_JSON] = () => v.toString('base64')
    } else {
      setBuffersToJSON(v, function() { // no =>, honor `this`
        return this.toString('base64')
      })
    }
    return this
  }

  // Expected conversion to base16 encoding; see Section Section 3.4.5.2
  static _tag_23(v) {
    if (Buffer.isBuffer(v)) {
      this[INTERNAL_JSON] = () => v.toString('hex')
    } else {
      setBuffersToJSON(v, function() { // no =>, honor `this`
        return this.toString('hex')
      })
    }
    return this
  }

  // URI; see Section 3.4.5.3
  static _tag_32(v) {
    return new URL(v)
  }

  // base64url; see Section 3.4.5.3
  static _tag_33(v) {
    // If any of the following apply:
    // -  the encoded text string contains non-alphabet characters or
    //    only 1 alphabet character in the last block of 4 (where
    //    alphabet is defined by Section 5 of [RFC4648] for tag number 33
    //    and Section 4 of [RFC4648] for tag number 34), or
    if (!v.match(/^[a-zA-Z0-9_-]+$/)) {
      throw new Error('Invalid base64url characters')
    }
    const last = v.length % 4
    if (last === 1) {
      throw new Error('Invalid base64url length')
    }
    // -  the padding bits in a 2- or 3-character block are not 0, or
    if (last === 2) {
      // The last 4 bits of the last character need to be zero.
      if ('AQgw'.indexOf(v[v.length-1]) === -1) {
        throw new Error('Invalid base64 padding')
      }
    } else if (last === 3) {
      // The last 2 bits of the last character need to be zero.
      if ('AEIMQUYcgkosw048'.indexOf(v[v.length-1]) === -1) {
        throw new Error('Invalid base64 padding')
      }
    }

    //    or
    // -  the base64url encoding has padding characters,
    // (caught above)

    // the string is invalid.
    return this
  }

  // base64; see Section 3.4.5.3
  static _tag_34(v) {
    // If any of the following apply:
    // -  the encoded text string contains non-alphabet characters or
    //    only 1 alphabet character in the last block of 4 (where
    //    alphabet is defined by Section 5 of [RFC4648] for tag number 33
    //    and Section 4 of [RFC4648] for tag number 34), or
    const m = v.match(/^[a-zA-Z0-9+/]+(={0,2})$/)
    if (!m) {
      throw new Error('Invalid base64url characters')
    }
    if ((v.length % 4) !== 0) {
      throw new Error('Invalid base64url length')
    }
    // -  the padding bits in a 2- or 3-character block are not 0, or
    if (m[1] === '=') {
      // The last 4 bits of the last character need to be zero.
      if ('AQgw'.indexOf(v[v.length-2]) === -1) {
        throw new Error('Invalid base64 padding')
      }
    } else if (m[1] === '==') {
      // The last 2 bits of the last character need to be zero.
      if ('AEIMQUYcgkosw048'.indexOf(v[v.length-3]) === -1) {
        throw new Error('Invalid base64 padding')
      }
    }

    // -  the base64 encoding has the wrong number of padding characters,
    // (caught above)
    // the string is invalid.
    return this
  }

  // Regular expression; see Section 2.4.4.3
  static _tag_35(v) {
    return new RegExp(v)
  }
}
Tagged.INTERNAL_JSON = INTERNAL_JSON
module.exports = Tagged

1	'use strict'
2
3	const constants = require('./constants')	113✔
4	const utils = require('./utils')	113✔
5	const { Buffer } = require('buffer')	113✔
6
7	function setBuffersToJSON(obj, fn) {
8	// The data item tagged can be a byte string or any other data item. In the
9	// latter case, the tag applies to all of the byte string data items
10	// contained in the data item, except for those contained in a nested data
11	// item tagged with an expected conversion.
12	if (Buffer.isBuffer(obj)) {	76✔
13	obj.toJSON = fn	24✔
14	} else if (Array.isArray(obj)) {	52✔
15	for (const v of obj) {	28✔
16	setBuffersToJSON(v, fn)	28✔
17	}
18	} else if (obj && (typeof obj === 'object')) {	24✔
19	// ffs, complexity in the protocol.
20	if (!(obj instanceof Tagged) \|\| (obj.tag < 21) \|\| (obj.tag > 23)) {	20✔
21	for (const v of Object.values(obj)) {	16✔
22	setBuffersToJSON(v, fn)	16✔
23	}
24	}
25	}
26	}
27
28	const INTERNAL_JSON = Symbol('INTERNAL_JSON')	113✔
29	/**
30	* A CBOR tagged item, where the tag does not have semantics specified at the
31	* moment, or those semantics threw an error during parsing. Typically this will
32	* be an extension point you're not yet expecting.
33	*/
34	class Tagged {
35
36	/**
37	* Creates an instance of Tagged.
38	*
39	* @param {number} tag - the number of the tag
40	* @param {any} value - the value inside the tag
41	* @param {Error} [err] - the error that was thrown parsing the tag, or null
42	*/
43	constructor(tag, value, err) {
44	this.tag = tag	700✔
45	this.value = value	700✔
46	this.err = err	700✔
47	if (typeof this.tag !== 'number') {	700✔
48	throw new Error('Invalid tag type (' + (typeof this.tag) + ')')	4✔
49	}
50	if ((this.tag < 0) \|\| ((this.tag \| 0) !== this.tag)) {	696✔
51	throw new Error('Tag must be a positive integer: ' + this.tag)	8✔
52	}
53	}
54
55	toJSON() {
56	if (this[INTERNAL_JSON]) {	48✔
57	return this[INTERNAL_JSON]()	16✔
58	}
59	const ret = {	32✔
60	tag: this.tag,
61	value: this.value
62	}
63	if (this.err) {	32!
NEW 64	ret.err = this.err	×
65	}
66	return ret	32✔
67	}
68
69	/**
70	* Convert to a String
71	*
72	* @returns {string} string of the form '1(2)'
73	*/
74	toString() {
75	return `${this.tag}(${JSON.stringify(this.value)})`	4✔
76	}
77
78	/**
79	* Push the simple value onto the CBOR stream
80	*
81	* @param {Object} gen The generator to push onto
82	*/
83	encodeCBOR(gen) {
84	gen._pushTag(this.tag)	16✔
85	return gen.pushAny(this.value)	16✔
86	}
87
88	/**
89	* If we have a converter for this type, do the conversion. Some converters
90	* are built-in. Additional ones can be passed in. If you want to remove
91	* a built-in converter, pass a converter in whose value is 'null' instead
92	* of a function.
93	*
94	* @param {Object} converters - keys in the object are a tag number, the value
95	* is a function that takes the decoded CBOR and returns a JavaScript value
96	* of the appropriate type. Throw an exception in the function on errors.
97	* @returns {any} - the converted item
98	*/
99	convert(converters) {
100	let f = converters != null ? converters[this.tag] : void 0	508✔
101	if (typeof f !== 'function') {	508✔
102	f = Tagged['_tag_' + this.tag]	380✔
103	if (typeof f !== 'function') {	380✔
104	return this	60✔
105	}
106	}
107	try {	448✔
108	return f.call(this, this.value)	448✔
109	} catch (error) {
110	if (error && error.message) {	52!
111	this.err = error.message	52✔
112	} else {
NEW 113	this.err = error	×
114	}
115	return this	52✔
116	}
117	}
118
119	// Standard date/time string; see Section 3.4.1
120	static _tag_0(v) {
121	return new Date(v)	20✔
122	}
123
124	// Epoch-based date/time; see Section 3.4.2
125	static _tag_1(v) {
126	return new Date(v * 1000)	64✔
127	}
128
129	// Positive bignum; see Section 3.4.3
130	static _tag_2(v) {
131	// (note: replaced by bigint version in decoder.js when bigint on)
132	return utils.bufferToBignumber(v) // throws if no BigNumber	12✔
133	}
134
135	// Negative bignum; see Section 3.4.3
136	static _tag_3(v) {
137	// (note: replaced by bigint version in decoder.js when bigint on)
138	const pos = utils.bufferToBignumber(v) // throws if no BigNumber	4✔
139	return constants.BN.MINUS_ONE.minus(pos)	4✔
140	}
141
142	// Decimal fraction; see Section 3.4.4
143	static _tag_4(v) {
144	if (!constants.BigNumber) {	52✔
145	throw new Error('No bignumber.js')	4✔
146	}
147	return new constants.BigNumber(v[1]).shiftedBy(v[0])	48✔
148	}
149
150	// Bigfloat; see Section 3.4.4
151	static _tag_5(v) {
152	if (!constants.BigNumber) {	12✔
153	throw new Error('No bignumber.js')	4✔
154	}
155	return constants.BN.TWO.pow(v[0]).times(v[1])	8✔
156	}
157
158	// Expected conversion to base64url encoding; see Section 3.4.5.2
159	static _tag_21(v) {
160	if (Buffer.isBuffer(v)) {	20✔
161	this[INTERNAL_JSON] = () => utils.base64url(v)	4✔
162	} else {
163	setBuffersToJSON(v, function() { // no =>, honor `this`	16✔
164	return utils.base64url(this)	8✔
165	})
166	}
167	return this	20✔
168	}
169
170	// Expected conversion to base64 encoding; see Section 3.4.5.2
171	static _tag_22(v) {
172	if (Buffer.isBuffer(v)) {	16✔
173	this[INTERNAL_JSON] = () => v.toString('base64')	8✔
174	} else {
175	setBuffersToJSON(v, function() { // no =>, honor `this`	8✔
176	return this.toString('base64')	8✔
177	})
178	}
179	return this	16✔
180	}
181
182	// Expected conversion to base16 encoding; see Section Section 3.4.5.2
183	static _tag_23(v) {
184	if (Buffer.isBuffer(v)) {	32✔
185	this[INTERNAL_JSON] = () => v.toString('hex')	24✔
186	} else {
187	setBuffersToJSON(v, function() { // no =>, honor `this`	8✔
188	return this.toString('hex')	8✔
189	})
190	}
191	return this	32✔
192	}
193
194	// URI; see Section 3.4.5.3
195	static _tag_32(v) {
196	return new URL(v)	20✔
197	}
198
199	// base64url; see Section 3.4.5.3
200	static _tag_33(v) {
201	// If any of the following apply:
202	// - the encoded text string contains non-alphabet characters or
203	// only 1 alphabet character in the last block of 4 (where
204	// alphabet is defined by Section 5 of [RFC4648] for tag number 33
205	// and Section 4 of [RFC4648] for tag number 34), or
206	if (!v.match(/^[a-zA-Z0-9_-]+$/)) {	28✔
207	throw new Error('Invalid base64url characters')	4✔
208	}
209	const last = v.length % 4	24✔
210	if (last === 1) {	24✔
211	throw new Error('Invalid base64url length')	4✔
212	}
213	// - the padding bits in a 2- or 3-character block are not 0, or
214	if (last === 2) {	20✔
215	// The last 4 bits of the last character need to be zero.
216	if ('AQgw'.indexOf(v[v.length-1]) === -1) {	8✔
217	throw new Error('Invalid base64 padding')	4✔
218	}
219	} else if (last === 3) {	12✔
220	// The last 2 bits of the last character need to be zero.
221	if ('AEIMQUYcgkosw048'.indexOf(v[v.length-1]) === -1) {	8✔
222	throw new Error('Invalid base64 padding')	4✔
223	}
224	}
225
226	// or
227	// - the base64url encoding has padding characters,
228	// (caught above)
229
230	// the string is invalid.
231	return this	12✔
232	}
233
234	// base64; see Section 3.4.5.3
235	static _tag_34(v) {
236	// If any of the following apply:
237	// - the encoded text string contains non-alphabet characters or
238	// only 1 alphabet character in the last block of 4 (where
239	// alphabet is defined by Section 5 of [RFC4648] for tag number 33
240	// and Section 4 of [RFC4648] for tag number 34), or
241	const m = v.match(/^[a-zA-Z0-9+/]+(={0,2})$/)	32✔
242	if (!m) {	32✔
243	throw new Error('Invalid base64url characters')	8✔
244	}
245	if ((v.length % 4) !== 0) {	24✔
246	throw new Error('Invalid base64url length')	4✔
247	}
248	// - the padding bits in a 2- or 3-character block are not 0, or
249	if (m[1] === '=') {	20✔
250	// The last 4 bits of the last character need to be zero.
251	if ('AQgw'.indexOf(v[v.length-2]) === -1) {	8✔
252	throw new Error('Invalid base64 padding')	4✔
253	}
254	} else if (m[1] === '==') {	12✔
255	// The last 2 bits of the last character need to be zero.
256	if ('AEIMQUYcgkosw048'.indexOf(v[v.length-3]) === -1) {	8✔
257	throw new Error('Invalid base64 padding')	4✔
258	}
259	}
260
261	// - the base64 encoding has the wrong number of padding characters,
262	// (caught above)
263	// the string is invalid.
264	return this	12✔
265	}
266
267	// Regular expression; see Section 2.4.4.3
268	static _tag_35(v) {
269	return new RegExp(v)	8✔
270	}
271	}
272	Tagged.INTERNAL_JSON = INTERNAL_JSON	113✔
273	module.exports = Tagged	113✔

hildjj / node-cbor / 552264378

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous