cborg 1.4.2 → 1.5.3

package/esm/lib/bin.js

@@ -5,51 +5,114 @@ import {
 } from '../cborg.js';
 import { tokensToDiagnostic } from './diagnostic.js';
 import {
-  fromHex,
+  fromHex as _fromHex,
   toHex
 } from './byte-utils.js';
-const cmd = process.argv[2];
 function usage(code) {
   console.error('Usage: cborg <command> <args>');
   console.error('Valid commands:');
-  console.error('\thex2diag <hex input>');
-  console.error('\thex2json [--pretty] <hex input>');
-  console.error('\tjson2hex \'<json input>\'');
+  console.error('\thex2diag [hex input]');
+  console.error('\thex2bin [hex input]');
+  console.error('\thex2json [--pretty] [hex input]');
+  console.error('\tbin2hex [binary input]');
+  console.error('\tbin2diag [binary input]');
+  console.error('\tbin2json [--pretty] [binary input]');
+  console.error('\tjson2hex \'[json input]\'');
+  console.error('\tjson2diag \'[json input]\'');
+  console.error('\tjson2bin \'[json input]\'');
+  console.error('Input may either be supplied as an argument or piped via stdin');
   process.exit(code || 0);
 }
-if (cmd === 'help') {
-  usage(0);
-} else if (cmd === 'hex2json') {
-  const argv = process.argv.filter(s => s !== '--pretty');
-  const pretty = argv.length !== process.argv.length;
-  if (argv.length < 4) {
-    console.error('hex2json requires a hexadecimal input string');
-    usage(1);
-  }
-  const bin = fromHex(argv[3]);
-  console.log(JSON.stringify(decode(bin), undefined, pretty ? 2 : undefined));
-} else if (cmd === 'hex2diag') {
-  if (process.argv.length < 4) {
-    console.error('hex2diag requires a hexadecimal input string');
-    usage(1);
+async function fromStdin() {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(chunk);
   }
-  const bin = fromHex(process.argv[3]);
-  for (const line of tokensToDiagnostic(bin)) {
-    console.log(line);
-  }
-} else if (cmd === 'json2hex') {
-  if (process.argv.length < 4) {
-    console.error('json2hex requires a JSON input string');
-    usage(1);
+  return Buffer.concat(chunks);
+}
+function fromHex(str) {
+  str = str.replace(/\r?\n/g, '');
+  if (!/^([0-9a-f]{2})*$/i.test(str)) {
+    throw new Error('Input string is not hexadecimal format');
   }
-  const obj = JSON.parse(process.argv[3]);
-  console.log(toHex(encode(obj)));
-} else {
-  if (process.argv.findIndex(a => a.endsWith('mocha')) === -1) {
-    if (cmd) {
-      console.error(`Unknown command: '${ cmd }'`);
-    }
-    usage(1);
+  return _fromHex(str);
+}
+function argvPretty() {
+  const argv = process.argv.filter(s => s !== '--pretty');
+  const pretty = argv.length !== process.argv.length;
+  return {
+    argv,
+    pretty
+  };
+}
+async function run() {
+  const cmd = process.argv[2];
+  switch (cmd) {
+  case 'help': {
+      return usage(0);
+    }
+  case 'hex2json': {
+      const {argv, pretty} = argvPretty();
+      const bin = fromHex(argv.length < 4 ? (await fromStdin()).toString() : argv[3]);
+      return console.log(JSON.stringify(decode(bin), undefined, pretty ? 2 : undefined));
+    }
+  case 'hex2diag': {
+      const bin = fromHex(process.argv.length < 4 ? (await fromStdin()).toString() : process.argv[3]);
+      for (const line of tokensToDiagnostic(bin)) {
+        console.log(line);
+      }
+      return;
+    }
+  case 'hex2bin': {
+      const bin = fromHex(process.argv.length < 4 ? (await fromStdin()).toString() : process.argv[3]);
+      return process.stdout.write(bin);
+    }
+  case 'bin2hex': {
+      const bin = process.argv.length < 4 ? await fromStdin() : new TextEncoder().encode(process.argv[3]);
+      return console.log(toHex(bin));
+    }
+  case 'bin2json': {
+      const {argv, pretty} = argvPretty();
+      const bin = argv.length < 4 ? await fromStdin() : new TextEncoder().encode(argv[3]);
+      return console.log(JSON.stringify(decode(bin), undefined, pretty ? 2 : undefined));
+    }
+  case 'bin2diag': {
+      const bin = process.argv.length < 4 ? await fromStdin() : new TextEncoder().encode(process.argv[3]);
+      for (const line of tokensToDiagnostic(bin)) {
+        console.log(line);
+      }
+      return;
+    }
+  case 'json2hex': {
+      const inp = process.argv.length < 4 ? (await fromStdin()).toString() : process.argv[3];
+      const obj = JSON.parse(inp);
+      return console.log(toHex(encode(obj)));
+    }
+  case 'json2diag': {
+      const inp = process.argv.length < 4 ? (await fromStdin()).toString() : process.argv[3];
+      const obj = JSON.parse(inp);
+      for (const line of tokensToDiagnostic(encode(obj))) {
+        console.log(line);
+      }
+      return;
+    }
+  case 'json2bin': {
+      const inp = process.argv.length < 4 ? (await fromStdin()).toString() : process.argv[3];
+      const obj = JSON.parse(inp);
+      return process.stdout.write(encode(obj));
+    }
+  default: {
+      if (process.argv.findIndex(a => a.endsWith('mocha')) === -1) {
+        if (cmd) {
+          console.error(`Unknown command: '${ cmd }'`);
+        }
+        usage(1);
+      }
+    }
   }
 }
+run().catch(err => {
+  console.error(err);
+  process.exit(1);
+});
 export default true;

package/esm/node-test/node-test-bin.js

@@ -6,9 +6,12 @@ import { fileURLToPath } from 'url';
 import bin from '../lib/bin.js';
 const {assert} = chai;
 const binPath = path.join(path.dirname(fileURLToPath(import.meta.url)), '../lib/bin.js');
-async function execBin(cmd) {
+function fromHex(hex) {
+  return new Uint8Array(hex.split('').map((c, i, d) => i % 2 === 0 ? `0x${ c }${ d[i + 1] }` : '').filter(Boolean).map(e => parseInt(e, 16)));
+}
+async function execBin(cmd, stdin) {
   return new Promise((resolve, reject) => {
-    exec(`"${ process.execPath }" "${ binPath }" ${ cmd }`, (err, stdout, stderr) => {
+    const cp = exec(`"${ process.execPath }" "${ binPath }" ${ cmd }`, (err, stdout, stderr) => {
       if (err) {
         err.stdout = stdout;
         err.stderr = stderr;
@@ -19,6 +22,12 @@ async function execBin(cmd) {
         stderr
       });
     });
+    if (stdin != null) {
+      cp.on('spawn', () => {
+        cp.stdin.write(stdin);
+        cp.stdin.end();
+      });
+    }
   });
 }
 describe('Bin', () => {
@@ -30,9 +39,16 @@ describe('Bin', () => {
       assert.strictEqual(e.stdout, '');
       assert.strictEqual(e.stderr, `Usage: cborg <command> <args>
 Valid commands:
-\thex2diag <hex input>
-\thex2json [--pretty] <hex input>
-\tjson2hex '<json input>'
+\thex2diag [hex input]
+\thex2bin [hex input]
+\thex2json [--pretty] [hex input]
+\tbin2hex [binary input]
+\tbin2diag [binary input]
+\tbin2json [--pretty] [binary input]
+\tjson2hex '[json input]'
+\tjson2diag '[json input]'
+\tjson2bin '[json input]'
+Input may either be supplied as an argument or piped via stdin
 `);
     }
   });
@@ -45,9 +61,16 @@ Valid commands:
       assert.strictEqual(e.stderr, `Unknown command: 'blip'
 Usage: cborg <command> <args>
 Valid commands:
-\thex2diag <hex input>
-\thex2json [--pretty] <hex input>
-\tjson2hex '<json input>'
+\thex2diag [hex input]
+\thex2bin [hex input]
+\thex2json [--pretty] [hex input]
+\tbin2hex [binary input]
+\tbin2diag [binary input]
+\tbin2json [--pretty] [binary input]
+\tjson2hex '[json input]'
+\tjson2diag '[json input]'
+\tjson2bin '[json input]'
+Input may either be supplied as an argument or piped via stdin
 `);
     }
   });
@@ -56,27 +79,31 @@ Valid commands:
     assert.strictEqual(stdout, '');
     assert.strictEqual(stderr, `Usage: cborg <command> <args>
 Valid commands:
-\thex2diag <hex input>
-\thex2json [--pretty] <hex input>
-\tjson2hex '<json input>'
+\thex2diag [hex input]
+\thex2bin [hex input]
+\thex2json [--pretty] [hex input]
+\tbin2hex [binary input]
+\tbin2diag [binary input]
+\tbin2json [--pretty] [binary input]
+\tjson2hex '[json input]'
+\tjson2diag '[json input]'
+\tjson2bin '[json input]'
+Input may either be supplied as an argument or piped via stdin
 `);
   });
-  it('hex2json', async () => {
-    const {stdout, stderr} = await execBin('hex2json a3616101616282020365736d696c6564f09f9880');
-    assert.strictEqual(stderr, '');
-    assert.strictEqual(stdout, '{"a":1,"b":[2,3],"smile":"\uD83D\uDE00"}\n');
-    try {
-      await execBin('hex2json');
-      assert.fail('should have errored');
-    } catch (e) {
-      assert.strictEqual(e.stdout, '');
-      assert.isTrue(e.stderr.startsWith('hex2json requires a hexadecimal input string\nUsage: '));
-    }
-  });
-  it('hex2json pretty', async () => {
-    const {stdout, stderr} = await execBin('hex2json --pretty a3616101616282020365736d696c6564f09f9880');
-    assert.strictEqual(stderr, '');
-    assert.strictEqual(stdout, `{
+  for (const stdin of [
+      true,
+      false
+    ]) {
+    it(`hex2json${ stdin ? ' (stdin)' : '' }`, async () => {
+      const {stdout, stderr} = stdin ? await execBin('hex2json a3616101616282020365736d696c6564f09f9880') : await execBin('hex2json', 'a3616101616282020365736d696c6564f09f9880');
+      assert.strictEqual(stderr, '');
+      assert.strictEqual(stdout, '{"a":1,"b":[2,3],"smile":"\uD83D\uDE00"}\n');
+    });
+    it(`hex2json pretty${ stdin ? ' (stdin)' : '' }`, async () => {
+      const {stdout, stderr} = stdin ? await execBin('hex2json --pretty a3616101616282020365736d696c6564f09f9880') : await execBin('hex2json --pretty', 'a3616101616282020365736d696c6564f09f9880');
+      assert.strictEqual(stderr, '');
+      assert.strictEqual(stdout, `{
   "a": 1,
   "b": [
     2,
@@ -85,11 +112,11 @@ Valid commands:
   "smile": "😀"
 }
 `);
-  });
-  it('hex2diag', async () => {
-    const {stdout, stderr} = await execBin('hex2diag a4616101616282020363627566440102036165736d696c6564f09f9880');
-    assert.strictEqual(stderr, '');
-    assert.strictEqual(stdout, `a4                                                # map(4)
+    });
+    it(`hex2diag${ stdin ? ' (stdin)' : '' }`, async () => {
+      const {stdout, stderr} = stdin ? await execBin('hex2diag a4616101616282020363627566440102036165736d696c6564f09f9880') : await execBin('hex2diag', 'a4616101616282020363627566440102036165736d696c6564f09f9880');
+      assert.strictEqual(stderr, '');
+      assert.strictEqual(stdout, `a4                                                # map(4)
   61                                              #   string(1)
     61                                            #     "a"
   01                                              #   uint(1)
@@ -107,24 +134,80 @@ Valid commands:
   64 f09f                                         #   string(2)
     f09f9880                                      #     "😀"
 `);
-    try {
-      await execBin('hex2diag');
-      assert.fail('should have errored');
-    } catch (e) {
-      assert.strictEqual(e.stdout, '');
-      assert.isTrue(e.stderr.startsWith('hex2diag requires a hexadecimal input string\nUsage: '));
-    }
+    });
+    it(`hex2bin${ stdin ? ' (stdin)' : '' }`, async () => {
+      const {stdout, stderr} = stdin ? await execBin('hex2bin a3616101616282020365736d696c6564f09f9880') : await execBin('hex2bin', 'a3616101616282020365736d696c6564f09f9880');
+      assert.strictEqual(stderr, '');
+      assert.strictEqual(stdout, new TextDecoder().decode(fromHex('a3616101616282020365736d696c6564f09f9880')));
+    });
+    it(`json2hex${ stdin ? ' (stdin)' : '' }`, async () => {
+      const {stdout, stderr} = stdin ? await execBin('json2hex "{\\"a\\":1,\\"b\\":[2,3],\\"smile\\":\\"\uD83D\uDE00\\"}"') : await execBin('json2hex', '{"a":1,"b":[2,3],"smile":"\uD83D\uDE00"}');
+      assert.strictEqual(stderr, '');
+      assert.strictEqual(stdout, 'a3616101616282020365736d696c6564f09f9880\n');
+    });
+    it(`json2bin${ stdin ? ' (stdin)' : '' }`, async () => {
+      const {stdout, stderr} = stdin ? await execBin('json2bin "{\\"a\\":1,\\"b\\":[2,3],\\"smile\\":\\"\uD83D\uDE00\\"}"') : await execBin('json2bin', '{"a":1,"b":[2,3],"smile":"\uD83D\uDE00"}');
+      assert.strictEqual(stderr, '');
+      assert.strictEqual(stdout, new TextDecoder().decode(fromHex('a3616101616282020365736d696c6564f09f9880')));
+    });
+    it(`json2diag${ stdin ? ' (stdin)' : '' }`, async () => {
+      const {stdout, stderr} = stdin ? await execBin('json2diag "{\\"a\\":1,\\"b\\":[2,3],\\"smile\\":\\"\uD83D\uDE00\\"}"') : await execBin('json2diag', '{"a":1,"b":[2,3],"smile":"\uD83D\uDE00"}');
+      assert.strictEqual(stderr, '');
+      assert.strictEqual(stdout, `a3                                                # map(3)
+  61                                              #   string(1)
+    61                                            #     "a"
+  01                                              #   uint(1)
+  61                                              #   string(1)
+    62                                            #     "b"
+  82                                              #   array(2)
+    02                                            #     uint(2)
+    03                                            #     uint(3)
+  65                                              #   string(5)
+    736d696c65                                    #     "smile"
+  64 f09f                                         #   string(2)
+    f09f9880                                      #     "😀"
+`);
+    });
+  }
+  it('bin2diag (stdin)', async () => {
+    const {stdout, stderr} = await execBin('bin2diag', fromHex('a3616101616282020365736d696c6564f09f9880'));
+    assert.strictEqual(stderr, '');
+    assert.strictEqual(stdout, `a3                                                # map(3)
+  61                                              #   string(1)
+    61                                            #     "a"
+  01                                              #   uint(1)
+  61                                              #   string(1)
+    62                                            #     "b"
+  82                                              #   array(2)
+    02                                            #     uint(2)
+    03                                            #     uint(3)
+  65                                              #   string(5)
+    736d696c65                                    #     "smile"
+  64 f09f                                         #   string(2)
+    f09f9880                                      #     "😀"
+`);
+  });
+  it('bin2json (stdin)', async () => {
+    const {stdout, stderr} = await execBin('bin2json', fromHex('a3616101616282020365736d696c6564f09f9880'));
+    assert.strictEqual(stderr, '');
+    assert.strictEqual(stdout, '{"a":1,"b":[2,3],"smile":"\uD83D\uDE00"}\n');
+  });
+  it('bin2json pretty (stdin)', async () => {
+    const {stdout, stderr} = await execBin('bin2json --pretty', fromHex('a3616101616282020365736d696c6564f09f9880'));
+    assert.strictEqual(stderr, '');
+    assert.strictEqual(stdout, `{
+  "a": 1,
+  "b": [
+    2,
+    3
+  ],
+  "smile": "😀"
+}
+`);
   });
-  it('json2hex', async () => {
-    const {stdout, stderr} = await execBin('json2hex "{\\"a\\":1,\\"b\\":[2,3],\\"smile\\":\\"\uD83D\uDE00\\"}"');
+  it('bin2hex (stdin)', async () => {
+    const {stdout, stderr} = await execBin('bin2hex', fromHex('a3616101616282020365736d696c6564f09f9880'));
     assert.strictEqual(stderr, '');
     assert.strictEqual(stdout, 'a3616101616282020365736d696c6564f09f9880\n');
-    try {
-      await execBin('json2hex');
-      assert.fail('should have errored');
-    } catch (e) {
-      assert.strictEqual(e.stdout, '');
-      assert.isTrue(e.stderr.startsWith('json2hex requires a JSON input string\nUsage: '));
-    }
   });
 });

package/lib/bin.js

@@ -3,9 +3,7 @@
 import process from 'process'
 import { decode, encode } from '../cborg.js'
 import { tokensToDiagnostic } from './diagnostic.js'
-import { fromHex, toHex } from './byte-utils.js'
-
-const cmd = process.argv[2]
+import { fromHex as _fromHex, toHex } from './byte-utils.js'
 
 /**
  * @param {number} code
@@ -13,50 +11,137 @@ const cmd = process.argv[2]
 function usage (code) {
   console.error('Usage: cborg <command> <args>')
   console.error('Valid commands:')
-  console.error('\thex2diag <hex input>')
-  console.error('\thex2json [--pretty] <hex input>')
-  console.error('\tjson2hex \'<json input>\'')
+  console.error('\thex2diag [hex input]')
+  console.error('\thex2bin [hex input]')
+  console.error('\thex2json [--pretty] [hex input]')
+  console.error('\tbin2hex [binary input]')
+  console.error('\tbin2diag [binary input]')
+  console.error('\tbin2json [--pretty] [binary input]')
+  console.error('\tjson2hex \'[json input]\'')
+  console.error('\tjson2diag \'[json input]\'')
+  console.error('\tjson2bin \'[json input]\'')
+  console.error('Input may either be supplied as an argument or piped via stdin')
   process.exit(code || 0)
 }
 
-if (cmd === 'help') {
-  usage(0)
-} else if (cmd === 'hex2json') {
-  const argv = process.argv.filter((s) => s !== '--pretty')
-  const pretty = argv.length !== process.argv.length
-  if (argv.length < 4) {
-    console.error('hex2json requires a hexadecimal input string')
-    usage(1)
-  }
-  const bin = fromHex(argv[3])
-  console.log(JSON.stringify(decode(bin), undefined, pretty ? 2 : undefined))
-} else if (cmd === 'hex2diag') {
-  if (process.argv.length < 4) {
-    console.error('hex2diag requires a hexadecimal input string')
-    usage(1)
-  }
-  const bin = fromHex(process.argv[3])
-  for (const line of tokensToDiagnostic(bin)) {
-    console.log(line)
+async function fromStdin () {
+  const chunks = []
+  for await (const chunk of process.stdin) {
+    chunks.push(chunk)
   }
-} else if (cmd === 'json2hex') {
-  if (process.argv.length < 4) {
-    console.error('json2hex requires a JSON input string')
-    usage(1)
+  return Buffer.concat(chunks)
+}
+
+/**
+ * @param {string} str
+ * @returns {Uint8Array}
+ */
+function fromHex (str) {
+  str = str.replace(/\r?\n/g, '') // let's be charitable
+  /* c8 ignore next 3 */
+  if (!(/^([0-9a-f]{2})*$/i).test(str)) {
+    throw new Error('Input string is not hexadecimal format')
   }
-  const obj = JSON.parse(process.argv[3])
-  console.log(toHex(encode(obj)))
-} else { // no, or unknown cmd
-  // this is a dirty hack to allow import of this package by the tests
-  // for inclusion in ipjs bundling, but to silently ignore it so we don't
-  // print usage and exit(1).
-  if (process.argv.findIndex((a) => a.endsWith('mocha')) === -1) {
-    if (cmd) {
-      console.error(`Unknown command: '${cmd}'`)
-    }
-    usage(1)
+  return _fromHex(str)
+}
+
+function argvPretty () {
+  const argv = process.argv.filter((s) => s !== '--pretty')
+  const pretty = argv.length !== process.argv.length
+  return { argv, pretty }
+}
+
+async function run () {
+  const cmd = process.argv[2]
+
+  switch (cmd) {
+    case 'help': {
+      return usage(0)
+    }
+
+    case 'hex2json': {
+      const { argv, pretty } = argvPretty()
+      const bin = fromHex(argv.length < 4 ? (await fromStdin()).toString() : argv[3])
+      return console.log(JSON.stringify(decode(bin), undefined, pretty ? 2 : undefined))
+    }
+
+    case 'hex2diag': {
+      const bin = fromHex(process.argv.length < 4 ? (await fromStdin()).toString() : process.argv[3])
+      for (const line of tokensToDiagnostic(bin)) {
+        console.log(line)
+      }
+      return
+    }
+
+    case 'hex2bin': {
+      // this is really nothing to do with cbor.. just handy
+      const bin = fromHex(process.argv.length < 4 ? (await fromStdin()).toString() : process.argv[3])
+      return process.stdout.write(bin)
+    }
+
+    case 'bin2hex': {
+      // this is really nothing to do with cbor.. just handy
+      /* c8 ignore next 1 */
+      const bin = process.argv.length < 4 ? (await fromStdin()) : new TextEncoder().encode(process.argv[3])
+      return console.log(toHex(bin))
+    }
+
+    case 'bin2json': {
+      const { argv, pretty } = argvPretty()
+      /* c8 ignore next 1 */
+      const bin = argv.length < 4 ? (await fromStdin()) : new TextEncoder().encode(argv[3])
+      return console.log(JSON.stringify(decode(bin), undefined, pretty ? 2 : undefined))
+    }
+
+    case 'bin2diag': {
+      /* c8 ignore next 1 */
+      const bin = process.argv.length < 4 ? (await fromStdin()) : new TextEncoder().encode(process.argv[3])
+      for (const line of tokensToDiagnostic(bin)) {
+        console.log(line)
+      }
+      return
+    }
+
+    case 'json2hex': {
+      const inp = process.argv.length < 4 ? (await fromStdin()).toString() : process.argv[3]
+      const obj = JSON.parse(inp)
+      return console.log(toHex(encode(obj)))
+    }
+
+    case 'json2diag': {
+      const inp = process.argv.length < 4 ? (await fromStdin()).toString() : process.argv[3]
+      const obj = JSON.parse(inp)
+      for (const line of tokensToDiagnostic(encode(obj))) {
+        console.log(line)
+      }
+      return
+    }
+
+    case 'json2bin': {
+      const inp = process.argv.length < 4 ? (await fromStdin()).toString() : process.argv[3]
+      const obj = JSON.parse(inp)
+      return process.stdout.write(encode(obj))
+    }
+
+    default: { // no, or unknown cmd
+      // this is a dirty hack to allow import of this package by the tests
+      // for inclusion in ipjs bundling, but to silently ignore it so we don't
+      // print usage and exit(1).
+      if (process.argv.findIndex((a) => a.endsWith('mocha')) === -1) {
+        if (cmd) {
+          console.error(`Unknown command: '${cmd}'`)
+        }
+        usage(1)
+      }
+    }
   }
 }
 
+run().catch((err) => {
+  /* c8 ignore next 2 */
+  console.error(err)
+  process.exit(1)
+})
+
 // for ipjs, to get it to compile
 export default true

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cborg",
-  "version": "1.4.2",
+  "version": "1.5.3",
   "description": "Fast CBOR with a focus on strictness",
   "main": "./cjs/cborg.js",
   "bin": {