From 9b8923844f643fa5e04ea85ce1df835c10e09b7d Mon Sep 17 00:00:00 2001 From: Ryan Dahl Date: Mon, 24 Dec 2018 10:28:01 -0500 Subject: [PATCH] Format (#42) --- README.md | 15 +- colors/README.md | 8 +- examples/README.md | 2 + flags/README.md | 37 ++--- flags/tests/all_bool.ts | 44 +++--- flags/tests/bool.ts | 244 +++++++++++++++---------------- flags/tests/dash.ts | 29 ++-- flags/tests/default_bool.ts | 43 +++--- flags/tests/dotted.ts | 19 ++- flags/tests/kv_short.ts | 8 +- flags/tests/long.ts | 33 ++--- flags/tests/num.ts | 57 ++++---- flags/tests/parse.ts | 284 +++++++++++++++++++----------------- flags/tests/short.ts | 77 ++++------ flags/tests/stop_early.ts | 14 +- flags/tests/unknown.ts | 150 +++++++++---------- flags/tests/whitespace.ts | 2 +- format.ts | 2 +- logging/README.md | 11 +- logging/handlers/console.ts | 44 +++--- path/README.md | 2 +- 21 files changed, 562 insertions(+), 563 deletions(-) diff --git a/README.md b/README.md index 1aa6eb5d66..74043c3e2f 100644 --- a/README.md +++ b/README.md @@ -5,13 +5,14 @@ This repository contains collections of modules that create a standard library for Deno. -| Collection | Description | -| ---------------------------- | --------------------------------------------------------------- | -| [colors](./colors/) | Modules that generate ANSI color codes for the console. | -| [net](./net/) | A framework for creating HTTP/HTTPS servers inspired by GoLang. | -| [path](./path/) | File path manipulation. | -| [flags](./flags/) | Command line arguments parser. | -| [logging](./logging/) | Command line logging | +| Collection | Description | +| --------------------- | --------------------------------------------------------------- | +| [colors](./colors/) | Modules that generate ANSI color codes for the console. | +| [net](./net/) | A framework for creating HTTP/HTTPS servers inspired by GoLang. | +| [path](./path/) | File path manipulation. | +| [flags](./flags/) | Command line arguments parser. | +| [logging](./logging/) | Command line logging | + --- Copyright 2018 the Deno authors. All rights reserved. MIT license. diff --git a/colors/README.md b/colors/README.md index f20d1939a9..bdaa3d51e9 100644 --- a/colors/README.md +++ b/colors/README.md @@ -6,8 +6,8 @@ inspired by packages like [chalk](https://www.npmjs.com/package/chalk) and ## Usage -The main modules exports a single function name `color` which is a function -that provides chaining to stack colors. Basic usage looks like this: +The main modules exports a single function name `color` which is a function that +provides chaining to stack colors. Basic usage looks like this: ```ts import { color } from "https://deno.land/x/colors/main.ts"; @@ -18,8 +18,8 @@ console.log(color.bgBlue.red.bold("Hello world!")); ## TODO - Currently, it just assumes it is running in an environment that supports ANSI - escape code terminal coloring. It should actually detect, specifically - windows and adjust properly. + escape code terminal coloring. It should actually detect, specifically windows + and adjust properly. - Test coverage is very basic at the moment. diff --git a/examples/README.md b/examples/README.md index 2e920f4796..874626ec4a 100644 --- a/examples/README.md +++ b/examples/README.md @@ -3,6 +3,7 @@ These files are accessible for import via "https://deno.land/x/examples/". Try it: + ``` > deno https://deno.land/x/examples/gist.ts README.md ``` @@ -10,6 +11,7 @@ Try it: ## Alias Based Installation Add this to your `.bash_profile` + ``` export GIST_TOKEN=ABC # Generate at https://github.com/settings/tokens alias gist="deno https://deno.land/x/examples/gist.ts --allow-net --allow-env" diff --git a/flags/README.md b/flags/README.md index 4afda374c5..9d09a2210f 100644 --- a/flags/README.md +++ b/flags/README.md @@ -4,7 +4,7 @@ Command line arguments parser for Deno based on minimist # Example -``` ts +```ts import { args } from "deno"; import { parse } from "https://deno.land/x/flags/index.ts"; @@ -32,8 +32,8 @@ $ deno example.ts -x 3 -y 4 -n5 -abc --beep=boop foo bar baz ## const parsedArgs = parse(args, options = {}); -`parsedArgs._` contains all the arguments that didn't have an option associated with -them. +`parsedArgs._` contains all the arguments that didn't have an option associated +with them. Numeric-looking arguments will be returned as numbers unless `options.string` or `options.boolean` is set for that argument name. @@ -42,18 +42,19 @@ Any arguments after `'--'` will not be parsed and will end up in `parsedArgs._`. options can be: -* `options.string` - a string or array of strings argument names to always treat as -strings -* `options.boolean` - a boolean, string or array of strings to always treat as -booleans. if `true` will treat all double hyphenated arguments without equal signs -as boolean (e.g. affects `--foo`, not `-f` or `--foo=bar`) -* `options.alias` - an object mapping string names to strings or arrays of string -argument names to use as aliases -* `options.default` - an object mapping string argument names to default values -* `options.stopEarly` - when true, populate `parsedArgs._` with everything after the -first non-option -* `options['--']` - when true, populate `parsedArgs._` with everything before the `--` -and `parsedArgs['--']` with everything after the `--`. Here's an example: -* `options.unknown` - a function which is invoked with a command line parameter not -defined in the `options` configuration object. If the function returns `false`, the -unknown option is not added to `parsedArgs`. +- `options.string` - a string or array of strings argument names to always treat + as strings +- `options.boolean` - a boolean, string or array of strings to always treat as + booleans. if `true` will treat all double hyphenated arguments without equal + signs as boolean (e.g. affects `--foo`, not `-f` or `--foo=bar`) +- `options.alias` - an object mapping string names to strings or arrays of + string argument names to use as aliases +- `options.default` - an object mapping string argument names to default values +- `options.stopEarly` - when true, populate `parsedArgs._` with everything after + the first non-option +- `options['--']` - when true, populate `parsedArgs._` with everything before + the `--` and `parsedArgs['--']` with everything after the `--`. Here's an + example: +- `options.unknown` - a function which is invoked with a command line parameter + not defined in the `options` configuration object. If the function returns + `false`, the unknown option is not added to `parsedArgs`. diff --git a/flags/tests/all_bool.ts b/flags/tests/all_bool.ts index aaa936bf63..879de5cc04 100755 --- a/flags/tests/all_bool.ts +++ b/flags/tests/all_bool.ts @@ -3,30 +3,30 @@ import { parse } from "../index.ts"; // flag boolean true (default all --args to boolean) test(function flagBooleanTrue() { - const argv = parse(['moo', '--honk', 'cow'], { - boolean: true - }); - - assertEqual(argv, { - honk: true, - _: ['moo', 'cow'] - }); - - assertEqual(typeof argv.honk, 'boolean'); + const argv = parse(["moo", "--honk", "cow"], { + boolean: true + }); + + assertEqual(argv, { + honk: true, + _: ["moo", "cow"] + }); + + assertEqual(typeof argv.honk, "boolean"); }); // flag boolean true only affects double hyphen arguments without equals signs test(function flagBooleanTrueOnlyAffectsDoubleDash() { - var argv = parse(['moo', '--honk', 'cow', '-p', '55', '--tacos=good'], { - boolean: true - }); - - assertEqual(argv, { - honk: true, - tacos: 'good', - p: 55, - _: ['moo', 'cow'] - }); - - assertEqual(typeof argv.honk, 'boolean'); + var argv = parse(["moo", "--honk", "cow", "-p", "55", "--tacos=good"], { + boolean: true + }); + + assertEqual(argv, { + honk: true, + tacos: "good", + p: 55, + _: ["moo", "cow"] + }); + + assertEqual(typeof argv.honk, "boolean"); }); diff --git a/flags/tests/bool.ts b/flags/tests/bool.ts index eae3df23cb..ee4f5e1c3b 100755 --- a/flags/tests/bool.ts +++ b/flags/tests/bool.ts @@ -2,157 +2,157 @@ import { test, assertEqual } from "https://deno.land/x/testing/testing.ts"; import { parse } from "../index.ts"; test(function flagBooleanDefaultFalse() { - const argv = parse(['moo'], { - boolean: ['t', 'verbose'], - default: { verbose: false, t: false } - }); - - assertEqual(argv, { - verbose: false, - t: false, - _: ['moo'] - }); - - assertEqual(typeof argv.verbose, 'boolean'); - assertEqual(typeof argv.t, 'boolean'); + const argv = parse(["moo"], { + boolean: ["t", "verbose"], + default: { verbose: false, t: false } + }); + + assertEqual(argv, { + verbose: false, + t: false, + _: ["moo"] + }); + + assertEqual(typeof argv.verbose, "boolean"); + assertEqual(typeof argv.t, "boolean"); }); test(function booleanGroups() { - const argv = parse([ '-x', '-z', 'one', 'two', 'three' ], { - boolean: ['x','y','z'] - }); - - assertEqual(argv, { - x : true, - y : false, - z : true, - _ : [ 'one', 'two', 'three' ] - }); - - assertEqual(typeof argv.x, 'boolean'); - assertEqual(typeof argv.y, 'boolean'); - assertEqual(typeof argv.z, 'boolean'); + const argv = parse(["-x", "-z", "one", "two", "three"], { + boolean: ["x", "y", "z"] + }); + + assertEqual(argv, { + x: true, + y: false, + z: true, + _: ["one", "two", "three"] + }); + + assertEqual(typeof argv.x, "boolean"); + assertEqual(typeof argv.y, "boolean"); + assertEqual(typeof argv.z, "boolean"); }); test(function booleanAndAliasWithChainableApi() { - const aliased = [ '-h', 'derp' ]; - const regular = [ '--herp', 'derp' ]; - const opts = { - herp: { alias: 'h', boolean: true } - }; - const aliasedArgv = parse(aliased, { - boolean: 'herp', - alias: { h: 'herp' } - }); - const propertyArgv = parse(regular, { - boolean: 'herp', - alias: { h: 'herp' } - }); - const expected = { - herp: true, - h: true, - '_': [ 'derp' ] - }; - - assertEqual(aliasedArgv, expected); - assertEqual(propertyArgv, expected); + const aliased = ["-h", "derp"]; + const regular = ["--herp", "derp"]; + const opts = { + herp: { alias: "h", boolean: true } + }; + const aliasedArgv = parse(aliased, { + boolean: "herp", + alias: { h: "herp" } + }); + const propertyArgv = parse(regular, { + boolean: "herp", + alias: { h: "herp" } + }); + const expected = { + herp: true, + h: true, + _: ["derp"] + }; + + assertEqual(aliasedArgv, expected); + assertEqual(propertyArgv, expected); }); test(function booleanAndAliasWithOptionsHash() { - const aliased = [ '-h', 'derp' ]; - const regular = [ '--herp', 'derp' ]; - const opts = { - alias: { 'h': 'herp' }, - boolean: 'herp' - }; - const aliasedArgv = parse(aliased, opts); - const propertyArgv = parse(regular, opts); - const expected = { - herp: true, - h: true, - '_': [ 'derp' ] - }; - assertEqual(aliasedArgv, expected); - assertEqual(propertyArgv, expected); + const aliased = ["-h", "derp"]; + const regular = ["--herp", "derp"]; + const opts = { + alias: { h: "herp" }, + boolean: "herp" + }; + const aliasedArgv = parse(aliased, opts); + const propertyArgv = parse(regular, opts); + const expected = { + herp: true, + h: true, + _: ["derp"] + }; + assertEqual(aliasedArgv, expected); + assertEqual(propertyArgv, expected); }); test(function booleanAndAliasArrayWithOptionsHash() { - const aliased = [ '-h', 'derp' ]; - const regular = [ '--herp', 'derp' ]; - const alt = [ '--harp', 'derp' ]; - const opts = { - alias: { 'h': ['herp', 'harp'] }, - boolean: 'h' - }; - const aliasedArgv = parse(aliased, opts); - const propertyArgv = parse(regular, opts); - const altPropertyArgv = parse(alt, opts); - const expected = { - harp: true, - herp: true, - h: true, - '_': [ 'derp' ] - }; - assertEqual(aliasedArgv, expected); - assertEqual(propertyArgv, expected); - assertEqual(altPropertyArgv, expected); + const aliased = ["-h", "derp"]; + const regular = ["--herp", "derp"]; + const alt = ["--harp", "derp"]; + const opts = { + alias: { h: ["herp", "harp"] }, + boolean: "h" + }; + const aliasedArgv = parse(aliased, opts); + const propertyArgv = parse(regular, opts); + const altPropertyArgv = parse(alt, opts); + const expected = { + harp: true, + herp: true, + h: true, + _: ["derp"] + }; + assertEqual(aliasedArgv, expected); + assertEqual(propertyArgv, expected); + assertEqual(altPropertyArgv, expected); }); test(function booleanAndAliasUsingExplicitTrue() { - const aliased = [ '-h', 'true' ]; - const regular = [ '--herp', 'true' ]; - const opts = { - alias: { h: 'herp' }, - boolean: 'h' - }; - const aliasedArgv = parse(aliased, opts); - const propertyArgv = parse(regular, opts); - const expected = { - herp: true, - h: true, - '_': [ ] - }; + const aliased = ["-h", "true"]; + const regular = ["--herp", "true"]; + const opts = { + alias: { h: "herp" }, + boolean: "h" + }; + const aliasedArgv = parse(aliased, opts); + const propertyArgv = parse(regular, opts); + const expected = { + herp: true, + h: true, + _: [] + }; - assertEqual(aliasedArgv, expected); - assertEqual(propertyArgv, expected); + assertEqual(aliasedArgv, expected); + assertEqual(propertyArgv, expected); }); // regression, see https://github.com/substack/node-optimist/issues/71 // boolean and --x=true test(function booleanAndNonBoolean() { - const parsed = parse(['--boool', '--other=true'], { - boolean: 'boool' - }); + const parsed = parse(["--boool", "--other=true"], { + boolean: "boool" + }); - assertEqual(parsed.boool, true); - assertEqual(parsed.other, 'true'); + assertEqual(parsed.boool, true); + assertEqual(parsed.other, "true"); - const parsed2 = parse(['--boool', '--other=false'], { - boolean: 'boool' - }); - - assertEqual(parsed2.boool, true); - assertEqual(parsed2.other, 'false'); + const parsed2 = parse(["--boool", "--other=false"], { + boolean: "boool" + }); + + assertEqual(parsed2.boool, true); + assertEqual(parsed2.other, "false"); }); test(function booleanParsingTrue() { - const parsed = parse(['--boool=true'], { - default: { - boool: false - }, - boolean: ['boool'] - }); + const parsed = parse(["--boool=true"], { + default: { + boool: false + }, + boolean: ["boool"] + }); - assertEqual(parsed.boool, true); + assertEqual(parsed.boool, true); }); test(function booleanParsingFalse() { - const parsed = parse(['--boool=false'], { - default: { - boool: true - }, - boolean: ['boool'] - }); + const parsed = parse(["--boool=false"], { + default: { + boool: true + }, + boolean: ["boool"] + }); - assertEqual(parsed.boool, false); + assertEqual(parsed.boool, false); }); diff --git a/flags/tests/dash.ts b/flags/tests/dash.ts index 5a55372c2c..2008cce43f 100755 --- a/flags/tests/dash.ts +++ b/flags/tests/dash.ts @@ -2,27 +2,22 @@ import { test, assertEqual } from "https://deno.land/x/testing/testing.ts"; import { parse } from "../index.ts"; test(function hyphen() { - assertEqual(parse([ '-n', '-' ]), { n: '-', _: [] }); - assertEqual(parse([ '-' ]), { _: [ '-' ] }); - assertEqual(parse([ '-f-' ]), { f: '-', _: [] }); - assertEqual( - parse([ '-b', '-' ], { boolean: 'b' }), - { b: true, _: [ '-' ] } - ); - assertEqual( - parse([ '-s', '-' ], { string: 's' }), - { s: '-', _: [] } - ); + assertEqual(parse(["-n", "-"]), { n: "-", _: [] }); + assertEqual(parse(["-"]), { _: ["-"] }); + assertEqual(parse(["-f-"]), { f: "-", _: [] }); + assertEqual(parse(["-b", "-"], { boolean: "b" }), { b: true, _: ["-"] }); + assertEqual(parse(["-s", "-"], { string: "s" }), { s: "-", _: [] }); }); test(function doubleDash() { - assertEqual(parse([ '-a', '--', 'b' ]), { a: true, _: [ 'b' ] }); - assertEqual(parse([ '--a', '--', 'b' ]), { a: true, _: [ 'b' ] }); - assertEqual(parse([ '--a', '--', 'b' ]), { a: true, _: [ 'b' ] }); + assertEqual(parse(["-a", "--", "b"]), { a: true, _: ["b"] }); + assertEqual(parse(["--a", "--", "b"]), { a: true, _: ["b"] }); + assertEqual(parse(["--a", "--", "b"]), { a: true, _: ["b"] }); }); test(function moveArgsAfterDoubleDashIntoOwnArray() { - assertEqual( - parse([ '--name', 'John', 'before', '--', 'after' ], { '--': true }), - { name: 'John', _: [ 'before' ], '--': [ 'after' ] }); + assertEqual( + parse(["--name", "John", "before", "--", "after"], { "--": true }), + { name: "John", _: ["before"], "--": ["after"] } + ); }); diff --git a/flags/tests/default_bool.ts b/flags/tests/default_bool.ts index 954ab2838b..b43c52e8dc 100755 --- a/flags/tests/default_bool.ts +++ b/flags/tests/default_bool.ts @@ -2,31 +2,30 @@ import { test, assertEqual } from "https://deno.land/x/testing/testing.ts"; import { parse } from "../index.ts"; test(function booleanDefaultTrue() { - const argv = parse([], { - boolean: 'sometrue', - default: { sometrue: true } - }); - assertEqual(argv.sometrue, true); + const argv = parse([], { + boolean: "sometrue", + default: { sometrue: true } + }); + assertEqual(argv.sometrue, true); }); test(function booleanDefaultFalse() { - const argv = parse([], { - boolean: 'somefalse', - default: { somefalse: false } - }); - assertEqual(argv.somefalse, false); + const argv = parse([], { + boolean: "somefalse", + default: { somefalse: false } + }); + assertEqual(argv.somefalse, false); }); test(function booleanDefaultNull() { - const argv = parse([], { - boolean: 'maybe', - default: { maybe: null } - }); - assertEqual(argv.maybe, null); - const argv2 = parse(['--maybe'], { - boolean: 'maybe', - default: { maybe: null } - }); - assertEqual(argv2.maybe, true); - -}) + const argv = parse([], { + boolean: "maybe", + default: { maybe: null } + }); + assertEqual(argv.maybe, null); + const argv2 = parse(["--maybe"], { + boolean: "maybe", + default: { maybe: null } + }); + assertEqual(argv2.maybe, true); +}); diff --git a/flags/tests/dotted.ts b/flags/tests/dotted.ts index 68f8d63c85..03f72dc838 100755 --- a/flags/tests/dotted.ts +++ b/flags/tests/dotted.ts @@ -2,18 +2,21 @@ import { test, assertEqual } from "https://deno.land/x/testing/testing.ts"; import { parse } from "../index.ts"; test(function dottedAlias() { - const argv = parse(['--a.b', '22'], {default: {'a.b': 11}, alias: {'a.b': 'aa.bb'}}); - assertEqual(argv.a.b, 22); - assertEqual(argv.aa.bb, 22); + const argv = parse(["--a.b", "22"], { + default: { "a.b": 11 }, + alias: { "a.b": "aa.bb" } + }); + assertEqual(argv.a.b, 22); + assertEqual(argv.aa.bb, 22); }); test(function dottedDefault() { - const argv = parse('', {default: {'a.b': 11}, alias: {'a.b': 'aa.bb'}}); - assertEqual(argv.a.b, 11); - assertEqual(argv.aa.bb, 11); + const argv = parse("", { default: { "a.b": 11 }, alias: { "a.b": "aa.bb" } }); + assertEqual(argv.a.b, 11); + assertEqual(argv.aa.bb, 11); }); test(function dottedDefaultWithNoAlias() { - const argv = parse('', {default: {'a.b': 11}}); - assertEqual(argv.a.b, 11); + const argv = parse("", { default: { "a.b": 11 } }); + assertEqual(argv.a.b, 11); }); diff --git a/flags/tests/kv_short.ts b/flags/tests/kv_short.ts index 545f722bd8..93aa763877 100755 --- a/flags/tests/kv_short.ts +++ b/flags/tests/kv_short.ts @@ -2,11 +2,11 @@ import { test, assertEqual } from "https://deno.land/x/testing/testing.ts"; import { parse } from "../index.ts"; test(function short() { - const argv = parse([ '-b=123' ]); - assertEqual(argv, { b: 123, _: [] }); + const argv = parse(["-b=123"]); + assertEqual(argv, { b: 123, _: [] }); }); test(function multiShort() { - const argv = parse([ '-a=whatever', '-b=robots' ]); - assertEqual(argv, { a: 'whatever', b: 'robots', _: [] }); + const argv = parse(["-a=whatever", "-b=robots"]); + assertEqual(argv, { a: "whatever", b: "robots", _: [] }); }); diff --git a/flags/tests/long.ts b/flags/tests/long.ts index 5a8cbf6c83..57e48ecbea 100755 --- a/flags/tests/long.ts +++ b/flags/tests/long.ts @@ -2,24 +2,17 @@ import { test, assertEqual } from "https://deno.land/x/testing/testing.ts"; import { parse } from "../index.ts"; test(function longOpts() { - assertEqual( - parse([ '--bool' ]), - { bool : true, _ : [] }, - ); - assertEqual( - parse([ '--pow', 'xixxle' ]), - { pow : 'xixxle', _ : [] }, - ); - assertEqual( - parse([ '--pow=xixxle' ]), - { pow : 'xixxle', _ : [] }, - ); - assertEqual( - parse([ '--host', 'localhost', '--port', '555' ]), - { host : 'localhost', port : 555, _ : [] }, - ); - assertEqual( - parse([ '--host=localhost', '--port=555' ]), - { host : 'localhost', port : 555, _ : [] }, - ); + assertEqual(parse(["--bool"]), { bool: true, _: [] }); + assertEqual(parse(["--pow", "xixxle"]), { pow: "xixxle", _: [] }); + assertEqual(parse(["--pow=xixxle"]), { pow: "xixxle", _: [] }); + assertEqual(parse(["--host", "localhost", "--port", "555"]), { + host: "localhost", + port: 555, + _: [] + }); + assertEqual(parse(["--host=localhost", "--port=555"]), { + host: "localhost", + port: 555, + _: [] + }); }); diff --git a/flags/tests/num.ts b/flags/tests/num.ts index c31a2fd4cb..66cbcb7ad2 100755 --- a/flags/tests/num.ts +++ b/flags/tests/num.ts @@ -2,33 +2,38 @@ import { test, assertEqual } from "https://deno.land/x/testing/testing.ts"; import { parse } from "../index.ts"; test(function nums() { - const argv = parse([ - '-x', '1234', - '-y', '5.67', - '-z', '1e7', - '-w', '10f', - '--hex', '0xdeadbeef', - '789' - ]); - assertEqual(argv, { - x : 1234, - y : 5.67, - z : 1e7, - w : '10f', - hex : 0xdeadbeef, - _ : [ 789 ] - }); - assertEqual(typeof argv.x, 'number'); - assertEqual(typeof argv.y, 'number'); - assertEqual(typeof argv.z, 'number'); - assertEqual(typeof argv.w, 'string'); - assertEqual(typeof argv.hex, 'number'); - assertEqual(typeof argv._[0], 'number'); + const argv = parse([ + "-x", + "1234", + "-y", + "5.67", + "-z", + "1e7", + "-w", + "10f", + "--hex", + "0xdeadbeef", + "789" + ]); + assertEqual(argv, { + x: 1234, + y: 5.67, + z: 1e7, + w: "10f", + hex: 0xdeadbeef, + _: [789] + }); + assertEqual(typeof argv.x, "number"); + assertEqual(typeof argv.y, "number"); + assertEqual(typeof argv.z, "number"); + assertEqual(typeof argv.w, "string"); + assertEqual(typeof argv.hex, "number"); + assertEqual(typeof argv._[0], "number"); }); test(function alreadyNumber() { - const argv = parse([ '-x', 1234, 789 ]); - assertEqual(argv, { x : 1234, _ : [ 789 ] }); - assertEqual(typeof argv.x, 'number'); - assertEqual(typeof argv._[0], 'number'); + const argv = parse(["-x", 1234, 789]); + assertEqual(argv, { x: 1234, _: [789] }); + assertEqual(typeof argv.x, "number"); + assertEqual(typeof argv._[0], "number"); }); diff --git a/flags/tests/parse.ts b/flags/tests/parse.ts index ca86e6aa11..29a500868a 100644 --- a/flags/tests/parse.ts +++ b/flags/tests/parse.ts @@ -1,182 +1,192 @@ import { test, assertEqual } from "https://deno.land/x/testing/testing.ts"; import { parse } from "../index.ts"; - test(function _arseArgs() { - assertEqual( - parse([ '--no-moo' ]), - { moo : false, _ : [] }, - ); - assertEqual( - parse([ '-v', 'a', '-v', 'b', '-v', 'c' ]), - { v : ['a','b','c'], _ : [] }, - ); + assertEqual(parse(["--no-moo"]), { moo: false, _: [] }); + assertEqual(parse(["-v", "a", "-v", "b", "-v", "c"]), { + v: ["a", "b", "c"], + _: [] + }); }); - + test(function comprehensive() { - assertEqual( - parse([ - '--name=meowmers', 'bare', '-cats', 'woo', - '-h', 'awesome', '--multi=quux', - '--key', 'value', - '-b', '--bool', '--no-meep', '--multi=baz', - '--', '--not-a-flag', 'eek' - ]), - { - c : true, - a : true, - t : true, - s : 'woo', - h : 'awesome', - b : true, - bool : true, - key : 'value', - multi : [ 'quux', 'baz' ], - meep : false, - name : 'meowmers', - _ : [ 'bare', '--not-a-flag', 'eek' ] - } - ); + assertEqual( + parse([ + "--name=meowmers", + "bare", + "-cats", + "woo", + "-h", + "awesome", + "--multi=quux", + "--key", + "value", + "-b", + "--bool", + "--no-meep", + "--multi=baz", + "--", + "--not-a-flag", + "eek" + ]), + { + c: true, + a: true, + t: true, + s: "woo", + h: "awesome", + b: true, + bool: true, + key: "value", + multi: ["quux", "baz"], + meep: false, + name: "meowmers", + _: ["bare", "--not-a-flag", "eek"] + } + ); }); test(function flagBoolean() { - const argv = parse([ '-t', 'moo' ], { boolean: 't' }); - assertEqual(argv, { t : true, _ : [ 'moo' ] }); - assertEqual(typeof argv.t, 'boolean'); + const argv = parse(["-t", "moo"], { boolean: "t" }); + assertEqual(argv, { t: true, _: ["moo"] }); + assertEqual(typeof argv.t, "boolean"); }); test(function flagBooleanValue() { - const argv = parse(['--verbose', 'false', 'moo', '-t', 'true'], { - boolean: [ 't', 'verbose' ], - default: { verbose: true } - }); - - assertEqual(argv, { - verbose: false, - t: true, - _: ['moo'] - }); - - assertEqual(typeof argv.verbose, 'boolean'); - assertEqual(typeof argv.t, 'boolean'); + const argv = parse(["--verbose", "false", "moo", "-t", "true"], { + boolean: ["t", "verbose"], + default: { verbose: true } + }); + + assertEqual(argv, { + verbose: false, + t: true, + _: ["moo"] + }); + + assertEqual(typeof argv.verbose, "boolean"); + assertEqual(typeof argv.t, "boolean"); }); test(function newlinesInParams() { - const args = parse([ '-s', "X\nX" ]) - assertEqual(args, { _ : [], s : "X\nX" }); - - // reproduce in bash: - // VALUE="new - // line" - // deno program.js --s="$VALUE" - const args2 = parse([ "--s=X\nX" ]) - assertEqual(args2, { _ : [], s : "X\nX" }); + const args = parse(["-s", "X\nX"]); + assertEqual(args, { _: [], s: "X\nX" }); + + // reproduce in bash: + // VALUE="new + // line" + // deno program.js --s="$VALUE" + const args2 = parse(["--s=X\nX"]); + assertEqual(args2, { _: [], s: "X\nX" }); }); test(function strings() { - const s = parse([ '-s', '0001234' ], { string: 's' }).s; - assertEqual(s, '0001234'); - assertEqual(typeof s, 'string'); - - const x = parse([ '-x', '56' ], { string: 'x' }).x; - assertEqual(x, '56'); - assertEqual(typeof x, 'string'); + const s = parse(["-s", "0001234"], { string: "s" }).s; + assertEqual(s, "0001234"); + assertEqual(typeof s, "string"); + + const x = parse(["-x", "56"], { string: "x" }).x; + assertEqual(x, "56"); + assertEqual(typeof x, "string"); }); test(function stringArgs() { - const s = parse([ ' ', ' ' ], { string: '_' })._; - assertEqual(s.length, 2); - assertEqual(typeof s[0], 'string'); - assertEqual(s[0], ' '); - assertEqual(typeof s[1], 'string'); - assertEqual(s[1], ' '); + const s = parse([" ", " "], { string: "_" })._; + assertEqual(s.length, 2); + assertEqual(typeof s[0], "string"); + assertEqual(s[0], " "); + assertEqual(typeof s[1], "string"); + assertEqual(s[1], " "); }); test(function emptyStrings() { - const s = parse([ '-s' ], { string: 's' }).s; - assertEqual(s, ''); - assertEqual(typeof s, 'string'); + const s = parse(["-s"], { string: "s" }).s; + assertEqual(s, ""); + assertEqual(typeof s, "string"); - const str = parse([ '--str' ], { string: 'str' }).str; - assertEqual(str, ''); - assertEqual(typeof str, 'string'); + const str = parse(["--str"], { string: "str" }).str; + assertEqual(str, ""); + assertEqual(typeof str, "string"); - const letters = parse([ '-art' ], { - string: [ 'a', 't' ] - }); + const letters = parse(["-art"], { + string: ["a", "t"] + }); - assertEqual(letters.a, ''); - assertEqual(letters.r, true); - assertEqual(letters.t, ''); + assertEqual(letters.a, ""); + assertEqual(letters.r, true); + assertEqual(letters.t, ""); }); - test(function stringAndAlias() { - const x = parse([ '--str', '000123' ], { - string: 's', - alias: { s: 'str' } - }); + const x = parse(["--str", "000123"], { + string: "s", + alias: { s: "str" } + }); - assertEqual(x.str, '000123'); - assertEqual(typeof x.str, 'string'); - assertEqual(x.s, '000123'); - assertEqual(typeof x.s, 'string'); + assertEqual(x.str, "000123"); + assertEqual(typeof x.str, "string"); + assertEqual(x.s, "000123"); + assertEqual(typeof x.s, "string"); - const y = parse([ '-s', '000123' ], { - string: 'str', - alias: { str: 's' } - }); + const y = parse(["-s", "000123"], { + string: "str", + alias: { str: "s" } + }); - assertEqual(y.str, '000123'); - assertEqual(typeof y.str, 'string'); - assertEqual(y.s, '000123'); - assertEqual(typeof y.s, 'string'); + assertEqual(y.str, "000123"); + assertEqual(typeof y.str, "string"); + assertEqual(y.s, "000123"); + assertEqual(typeof y.s, "string"); }); test(function slashBreak() { - assertEqual( - parse([ '-I/foo/bar/baz' ]), - { I : '/foo/bar/baz', _ : [] } - ); - assertEqual( - parse([ '-xyz/foo/bar/baz' ]), - { x : true, y : true, z : '/foo/bar/baz', _ : [] } - ); + assertEqual(parse(["-I/foo/bar/baz"]), { I: "/foo/bar/baz", _: [] }); + assertEqual(parse(["-xyz/foo/bar/baz"]), { + x: true, + y: true, + z: "/foo/bar/baz", + _: [] + }); }); test(function alias() { - const argv = parse([ '-f', '11', '--zoom', '55' ], { - alias: { z: 'zoom' } - }); - assertEqual(argv.zoom, 55); - assertEqual(argv.z, argv.zoom); - assertEqual(argv.f, 11); + const argv = parse(["-f", "11", "--zoom", "55"], { + alias: { z: "zoom" } + }); + assertEqual(argv.zoom, 55); + assertEqual(argv.z, argv.zoom); + assertEqual(argv.f, 11); }); test(function multiAlias() { - const argv = parse([ '-f', '11', '--zoom', '55' ], { - alias: { z: [ 'zm', 'zoom' ] } - }); - assertEqual(argv.zoom, 55); - assertEqual(argv.z, argv.zoom); - assertEqual(argv.z, argv.zm); - assertEqual(argv.f, 11); + const argv = parse(["-f", "11", "--zoom", "55"], { + alias: { z: ["zm", "zoom"] } + }); + assertEqual(argv.zoom, 55); + assertEqual(argv.z, argv.zoom); + assertEqual(argv.z, argv.zm); + assertEqual(argv.f, 11); }); test(function nestedDottedObjects() { - const argv = parse([ - '--foo.bar', '3', '--foo.baz', '4', - '--foo.quux.quibble', '5', '--foo.quux.o_O', - '--beep.boop' - ]); - - assertEqual(argv.foo, { - bar : 3, - baz : 4, - quux : { - quibble : 5, - o_O : true - } - }); - assertEqual(argv.beep, { boop : true }); -}); \ No newline at end of file + const argv = parse([ + "--foo.bar", + "3", + "--foo.baz", + "4", + "--foo.quux.quibble", + "5", + "--foo.quux.o_O", + "--beep.boop" + ]); + + assertEqual(argv.foo, { + bar: 3, + baz: 4, + quux: { + quibble: 5, + o_O: true + } + }); + assertEqual(argv.beep, { boop: true }); +}); diff --git a/flags/tests/short.ts b/flags/tests/short.ts index 7e1203c5ff..00c9dcc807 100755 --- a/flags/tests/short.ts +++ b/flags/tests/short.ts @@ -2,56 +2,43 @@ import { test, assertEqual } from "https://deno.land/x/testing/testing.ts"; import { parse } from "../index.ts"; test(function numbericShortArgs() { - assertEqual(parse([ '-n123' ]), { n: 123, _: [] }); - assertEqual( - parse([ '-123', '456' ]), - { 1: true, 2: true, 3: 456, _: [] } - ); + assertEqual(parse(["-n123"]), { n: 123, _: [] }); + assertEqual(parse(["-123", "456"]), { 1: true, 2: true, 3: 456, _: [] }); }); test(function short() { - assertEqual( - parse([ '-b' ]), - { b : true, _ : [] }, - ); - assertEqual( - parse([ 'foo', 'bar', 'baz' ]), - { _ : [ 'foo', 'bar', 'baz' ] }, - ); - assertEqual( - parse([ '-cats' ]), - { c : true, a : true, t : true, s : true, _ : [] }, - ); - assertEqual( - parse([ '-cats', 'meow' ]), - { c : true, a : true, t : true, s : 'meow', _ : [] }, - ); - assertEqual( - parse([ '-h', 'localhost' ]), - { h : 'localhost', _ : [] }, - ); - assertEqual( - parse([ '-h', 'localhost', '-p', '555' ]), - { h : 'localhost', p : 555, _ : [] }, - ); + assertEqual(parse(["-b"]), { b: true, _: [] }); + assertEqual(parse(["foo", "bar", "baz"]), { _: ["foo", "bar", "baz"] }); + assertEqual(parse(["-cats"]), { c: true, a: true, t: true, s: true, _: [] }); + assertEqual(parse(["-cats", "meow"]), { + c: true, + a: true, + t: true, + s: "meow", + _: [] + }); + assertEqual(parse(["-h", "localhost"]), { h: "localhost", _: [] }); + assertEqual(parse(["-h", "localhost", "-p", "555"]), { + h: "localhost", + p: 555, + _: [] + }); }); - + test(function mixedShortBoolAndCapture() { - assertEqual( - parse([ '-h', 'localhost', '-fp', '555', 'script.js' ]), - { - f : true, p : 555, h : 'localhost', - _ : [ 'script.js' ] - } - ); + assertEqual(parse(["-h", "localhost", "-fp", "555", "script.js"]), { + f: true, + p: 555, + h: "localhost", + _: ["script.js"] + }); }); - + test(function shortAndLong() { - assertEqual( - parse([ '-h', 'localhost', '-fp', '555', 'script.js' ]), - { - f : true, p : 555, h : 'localhost', - _ : [ 'script.js' ] - } - ); + assertEqual(parse(["-h", "localhost", "-fp", "555", "script.js"]), { + f: true, + p: 555, + h: "localhost", + _: ["script.js"] + }); }); diff --git a/flags/tests/stop_early.ts b/flags/tests/stop_early.ts index a47c9bd4ad..62725e6cfa 100755 --- a/flags/tests/stop_early.ts +++ b/flags/tests/stop_early.ts @@ -3,12 +3,12 @@ import { parse } from "../index.ts"; // stops parsing on the first non-option when stopEarly is set test(function stopParsing() { - const argv = parse(['--aaa', 'bbb', 'ccc', '--ddd'], { - stopEarly: true - }); + const argv = parse(["--aaa", "bbb", "ccc", "--ddd"], { + stopEarly: true + }); - assertEqual(argv, { - aaa: 'bbb', - _: ['ccc', '--ddd'] - }); + assertEqual(argv, { + aaa: "bbb", + _: ["ccc", "--ddd"] + }); }); diff --git a/flags/tests/unknown.ts b/flags/tests/unknown.ts index 8cc48285e8..ff5f2041c3 100755 --- a/flags/tests/unknown.ts +++ b/flags/tests/unknown.ts @@ -2,95 +2,95 @@ import { test, assertEqual } from "https://deno.land/x/testing/testing.ts"; import { parse } from "../index.ts"; test(function booleanAndAliasIsNotUnknown() { - const unknown = []; - function unknownFn(arg) { - unknown.push(arg); - return false; - } - const aliased = [ '-h', 'true', '--derp', 'true' ]; - const regular = [ '--herp', 'true', '-d', 'true' ]; - const opts = { - alias: { h: 'herp' }, - boolean: 'h', - unknown: unknownFn - }; - const aliasedArgv = parse(aliased, opts); - const propertyArgv = parse(regular, opts); + const unknown = []; + function unknownFn(arg) { + unknown.push(arg); + return false; + } + const aliased = ["-h", "true", "--derp", "true"]; + const regular = ["--herp", "true", "-d", "true"]; + const opts = { + alias: { h: "herp" }, + boolean: "h", + unknown: unknownFn + }; + const aliasedArgv = parse(aliased, opts); + const propertyArgv = parse(regular, opts); - assertEqual(unknown, ['--derp', '-d']); + assertEqual(unknown, ["--derp", "-d"]); }); test(function flagBooleanTrueAnyDoubleHyphenArgumentIsNotUnknown() { - const unknown = []; - function unknownFn(arg) { - unknown.push(arg); - return false; - } - const argv = parse(['--honk', '--tacos=good', 'cow', '-p', '55'], { - boolean: true, - unknown: unknownFn - }); - assertEqual(unknown, ['--tacos=good', 'cow', '-p']); - assertEqual(argv, { - honk: true, - _: [] - }); + const unknown = []; + function unknownFn(arg) { + unknown.push(arg); + return false; + } + const argv = parse(["--honk", "--tacos=good", "cow", "-p", "55"], { + boolean: true, + unknown: unknownFn + }); + assertEqual(unknown, ["--tacos=good", "cow", "-p"]); + assertEqual(argv, { + honk: true, + _: [] + }); }); test(function stringAndAliasIsNotUnkown() { - const unknown = []; - function unknownFn(arg) { - unknown.push(arg); - return false; - } - const aliased = [ '-h', 'hello', '--derp', 'goodbye' ]; - const regular = [ '--herp', 'hello', '-d', 'moon' ]; - const opts = { - alias: { h: 'herp' }, - string: 'h', - unknown: unknownFn - }; - const aliasedArgv = parse(aliased, opts); - const propertyArgv = parse(regular, opts); + const unknown = []; + function unknownFn(arg) { + unknown.push(arg); + return false; + } + const aliased = ["-h", "hello", "--derp", "goodbye"]; + const regular = ["--herp", "hello", "-d", "moon"]; + const opts = { + alias: { h: "herp" }, + string: "h", + unknown: unknownFn + }; + const aliasedArgv = parse(aliased, opts); + const propertyArgv = parse(regular, opts); - assertEqual(unknown, ['--derp', '-d']); + assertEqual(unknown, ["--derp", "-d"]); }); test(function defaultAndAliasIsNotUnknown() { - const unknown = []; - function unknownFn(arg) { - unknown.push(arg); - return false; - } - const aliased = [ '-h', 'hello' ]; - const regular = [ '--herp', 'hello' ]; - const opts = { - default: { 'h': 'bar' }, - alias: { 'h': 'herp' }, - unknown: unknownFn - }; - const aliasedArgv = parse(aliased, opts); - const propertyArgv = parse(regular, opts); + const unknown = []; + function unknownFn(arg) { + unknown.push(arg); + return false; + } + const aliased = ["-h", "hello"]; + const regular = ["--herp", "hello"]; + const opts = { + default: { h: "bar" }, + alias: { h: "herp" }, + unknown: unknownFn + }; + const aliasedArgv = parse(aliased, opts); + const propertyArgv = parse(regular, opts); - assertEqual(unknown, []); + assertEqual(unknown, []); }); test(function valueFollowingDoubleHyphenIsNotUnknown() { - const unknown = []; - function unknownFn(arg) { - unknown.push(arg); - return false; - } - const aliased = [ '--bad', '--', 'good', 'arg' ]; - const opts = { - '--': true, - unknown: unknownFn - }; - const argv = parse(aliased, opts); + const unknown = []; + function unknownFn(arg) { + unknown.push(arg); + return false; + } + const aliased = ["--bad", "--", "good", "arg"]; + const opts = { + "--": true, + unknown: unknownFn + }; + const argv = parse(aliased, opts); - assertEqual(unknown, ['--bad']); - assertEqual(argv, { - '--': ['good', 'arg'], - '_': [] - }) + assertEqual(unknown, ["--bad"]); + assertEqual(argv, { + "--": ["good", "arg"], + _: [] + }); }); diff --git a/flags/tests/whitespace.ts b/flags/tests/whitespace.ts index 24a291587b..f50518b4fa 100755 --- a/flags/tests/whitespace.ts +++ b/flags/tests/whitespace.ts @@ -2,5 +2,5 @@ import { test, assertEqual } from "https://deno.land/x/testing/testing.ts"; import { parse } from "../index.ts"; test(function whitespaceShouldBeWhitespace() { - assertEqual(parse([ '-x', '\t' ]).x, '\t'); + assertEqual(parse(["-x", "\t"]).x, "\t"); }); diff --git a/format.ts b/format.ts index 25a56641d9..949fa9ce96 100755 --- a/format.ts +++ b/format.ts @@ -27,7 +27,7 @@ async function main() { await checkVersion(); const prettier = run({ - args: ["bash", "-c", "prettier --write *.ts **/*.ts"] + args: ["bash", "-c", "prettier --write *.ts */**/*.ts *.md */**/*.md"] }); const s = await prettier.status(); exit(s.code); diff --git a/logging/README.md b/logging/README.md index b444b411b3..26047d9a2f 100644 --- a/logging/README.md +++ b/logging/README.md @@ -2,11 +2,14 @@ Very much work in progress. Contributions welcome. -This library is heavily inspired by Python's [logging](https://docs.python.org/3/library/logging.html#logging.Logger.log) module, altough -it's not planned to be a direct port. Having separate loggers, handlers, formatters and filters gives developer very granular control over logging -which is most desirable for server side software. +This library is heavily inspired by Python's +[logging](https://docs.python.org/3/library/logging.html#logging.Logger.log) +module, altough it's not planned to be a direct port. Having separate loggers, +handlers, formatters and filters gives developer very granular control over +logging which is most desirable for server side software. Todo: + - [ ] implement formatters - [ ] implement `FileHandler` -- [ ] tests \ No newline at end of file +- [ ] tests diff --git a/logging/handlers/console.ts b/logging/handlers/console.ts index 219a3baeca..8db0add314 100644 --- a/logging/handlers/console.ts +++ b/logging/handlers/console.ts @@ -1,26 +1,26 @@ -import { BaseHandler } from '../handler.ts'; -import { LogLevel } from '../levels.ts'; +import { BaseHandler } from "../handler.ts"; +import { LogLevel } from "../levels.ts"; export class ConsoleHandler extends BaseHandler { - _log(level, ...args) { - switch (level) { - case LogLevel.DEBUG: - console.log(...args); - return; - case LogLevel.INFO: - console.info(...args); - return; - case LogLevel.WARNING: - console.warn(...args); - return; - case LogLevel.ERROR: - console.error(...args); - return; - case LogLevel.CRITICAL: - console.error(...args); - return; - default: - return; - } + _log(level, ...args) { + switch (level) { + case LogLevel.DEBUG: + console.log(...args); + return; + case LogLevel.INFO: + console.info(...args); + return; + case LogLevel.WARNING: + console.warn(...args); + return; + case LogLevel.ERROR: + console.error(...args); + return; + case LogLevel.CRITICAL: + console.error(...args); + return; + default: + return; } + } } diff --git a/path/README.md b/path/README.md index d4f693577f..924b0a993f 100644 --- a/path/README.md +++ b/path/README.md @@ -3,5 +3,5 @@ Usage: ```ts -import * as path from 'https://deno.land/x/path/index.ts' +import * as path from "https://deno.land/x/path/index.ts"; ```