lint

types/argparse/argparse-tests.ts

@@ -1,25 +1,24 @@
-
 // near copy of each of the tests from https://github.com/nodeca/argparse/tree/master/examples
 
 import { ArgumentParser, RawDescriptionHelpFormatter } from 'argparse';
-var args: any;
+let args: any;
 
-var simpleExample = new ArgumentParser({
-  version: '0.0.1',
-  addHelp: true,
-  description: 'Argparse example',
+const simpleExample = new ArgumentParser({
+    version: '0.0.1',
+    addHelp: true,
+    description: 'Argparse example',
 });
 simpleExample.addArgument(
-  ['-f', '--foo'],
-  {
-    help: 'foo bar',
-  }
+    ['-f', '--foo'],
+    {
+        help: 'foo bar',
+    }
 );
 simpleExample.addArgument(
-  ['-b', '--bar'],
-  {
-    help: 'bar foo',
-  }
+    ['-b', '--bar'],
+    {
+        help: 'bar foo',
+    }
 );
 
 simpleExample.printHelp();
@@ -35,13 +34,10 @@ args = simpleExample.parseArgs('--foo 5 --bar 6'.split(' '));
 console.dir(args);
 console.log('-----------');
 
-
-
-
-var choicesExample = new ArgumentParser({
-  version: '0.0.1',
-  addHelp: true,
-  description: 'Argparse examples: choice'
+const choicesExample = new ArgumentParser({
+    version: '0.0.1',
+    addHelp: true,
+    description: 'Argparse examples: choice'
 });
 
 choicesExample.addArgument(['foo'], { choices: 'abc' });
@@ -55,56 +51,53 @@ console.log('-----------');
 // choicesExample.parseArgs(['X']);
 // console.dir(args);
 
-
-
-
-var constantExample = new ArgumentParser({
-  version: '0.0.1',
-  addHelp: true,
-  description: 'Argparse examples: constant'
+const constantExample = new ArgumentParser({
+    version: '0.0.1',
+    addHelp: true,
+    description: 'Argparse examples: constant'
 });
 
 constantExample.addArgument(
-  ['-a'],
-  {
-    action: 'storeConst',
-    dest: 'answer',
-    help: 'store constant',
-    constant: 42
-  }
+    ['-a'],
+    {
+        action: 'storeConst',
+        dest: 'answer',
+        help: 'store constant',
+        constant: 42
+    }
 );
 constantExample.addArgument(
-  ['--str'],
-  {
-    action: 'appendConst',
-    dest: 'types',
-    help: 'append constant "str" to types',
-    constant: 'str'
-  }
+    ['--str'],
+    {
+        action: 'appendConst',
+        dest: 'types',
+        help: 'append constant "str" to types',
+        constant: 'str'
+    }
 );
 constantExample.addArgument(
-  ['--int'],
-  {
-    action: 'appendConst',
-    dest: 'types',
-    help: 'append constant "int" to types',
-    constant: 'int'
-  }
+    ['--int'],
+    {
+        action: 'appendConst',
+        dest: 'types',
+        help: 'append constant "int" to types',
+        constant: 'int'
+    }
 );
 
 constantExample.addArgument(
-  ['--true'],
-  {
-    action: 'storeTrue',
-    help: 'store true constant'
-  }
+    ['--true'],
+    {
+        action: 'storeTrue',
+        help: 'store true constant'
+    }
 );
 constantExample.addArgument(
-  ['--false'],
-  {
-    action: 'storeFalse',
-    help: 'store false constant'
-  }
+    ['--false'],
+    {
+        action: 'storeFalse',
+        help: 'store false constant'
+    }
 );
 
 constantExample.printHelp();
@@ -113,27 +106,24 @@ console.log('-----------');
 args = constantExample.parseArgs('-a --str --int --true'.split(' '));
 console.dir(args);
 
-
-
-
-var nargsExample = new ArgumentParser({
-  version: '0.0.1',
-  addHelp: true,
-  description: 'Argparse examples: nargs'
+const nargsExample = new ArgumentParser({
+    version: '0.0.1',
+    addHelp: true,
+    description: 'Argparse examples: nargs'
 });
 nargsExample.addArgument(
-  ['-f', '--foo'],
-  {
-    help: 'foo bar',
-    nargs: 1
-  }
+    ['-f', '--foo'],
+    {
+        help: 'foo bar',
+        nargs: 1
+    }
 );
 nargsExample.addArgument(
-  ['-b', '--bar'],
-  {
-    help: 'bar foo',
-    nargs: '*'
-  }
+    ['-b', '--bar'],
+    {
+        help: 'bar foo',
+        nargs: '*'
+    }
 );
 
 nargsExample.printHelp();
@@ -145,40 +135,34 @@ console.log('-----------');
 args = nargsExample.parseArgs('--bar b c f --foo a'.split(' '));
 console.dir(args);
 
-
-
-
-var parent_parser = new ArgumentParser({ addHelp: false });
+const parent_parser = new ArgumentParser({ addHelp: false });
 // note addHelp:false to prevent duplication of the -h option
 parent_parser.addArgument(
-  ['--parent'],
-  { type: 'int', help: 'parent' }
+    ['--parent'],
+    { type: 'int', help: 'parent' }
 );
 
-var foo_parser = new ArgumentParser({
-  parents: [parent_parser],
-  description: 'child1'
+const foo_parser = new ArgumentParser({
+    parents: [parent_parser],
+    description: 'child1'
 });
 foo_parser.addArgument(['foo']);
 args = foo_parser.parseArgs(['--parent', '2', 'XXX']);
 console.log(args);
 
-var bar_parser = new ArgumentParser({
-  parents: [parent_parser],
-  description: 'child2'
+const bar_parser = new ArgumentParser({
+    parents: [parent_parser],
+    description: 'child2'
 });
 bar_parser.addArgument(['--bar']);
 args = bar_parser.parseArgs(['--bar', 'YYY']);
 console.log(args);
 
-
-
-
-var prefixCharsExample = new ArgumentParser({
-  version: '0.0.1',
-  addHelp: true,
-  description: 'Argparse examples: prefix_chars',
-  prefixChars: '-+'
+const prefixCharsExample = new ArgumentParser({
+    version: '0.0.1',
+    addHelp: true,
+    description: 'Argparse examples: prefix_chars',
+    prefixChars: '-+'
 });
 prefixCharsExample.addArgument(['+f', '++foo']);
 prefixCharsExample.addArgument(['++bar'], { action: 'storeTrue' });
@@ -193,39 +177,36 @@ console.dir(args);
 args = prefixCharsExample.parseArgs(['++foo', '2', '++bar']);
 console.dir(args);
 
-
-
-
-var subparserExample = new ArgumentParser({
-  version: '0.0.1',
-  addHelp: true,
-  description: 'Argparse examples: sub-commands'
+const subparserExample = new ArgumentParser({
+    version: '0.0.1',
+    addHelp: true,
+    description: 'Argparse examples: sub-commands'
 });
 
-var subparsers = subparserExample.addSubparsers({
-  title: 'subcommands',
-  dest: "subcommand_name"
+const subparsers = subparserExample.addSubparsers({
+    title: 'subcommands',
+    dest: "subcommand_name"
 });
 
-var bar = subparsers.addParser('c1', { addHelp: true, help: 'c1 help' });
+let bar = subparsers.addParser('c1', { addHelp: true, help: 'c1 help' });
 bar.addArgument(
-  ['-f', '--foo'],
-  {
-    action: 'store',
-    help: 'foo3 bar3'
-  }
+    ['-f', '--foo'],
+    {
+        action: 'store',
+        help: 'foo3 bar3'
+    }
 );
-var bar = subparsers.addParser(
-  'c2',
-  { aliases: ['co'], addHelp: true, help: 'c2 help' }
+bar = subparsers.addParser(
+    'c2',
+    { aliases: ['co'], addHelp: true, help: 'c2 help' }
 );
 bar.addArgument(
-  ['-b', '--bar'],
-  {
-    action: 'store',
-    type: 'int',
-    help: 'foo3 bar3'
-  }
+    ['-b', '--bar'],
+    {
+        action: 'store',
+        type: 'int',
+        help: 'foo3 bar3'
+    }
 );
 subparserExample.printHelp();
 console.log('-----------');
@@ -241,66 +222,57 @@ console.dir(args);
 console.log('-----------');
 subparserExample.parseArgs(['c1', '-h']);
 
-
-
-
-var functionExample = new ArgumentParser({ description: 'Process some integers.' });
+const functionExample = new ArgumentParser({ description: 'Process some integers.' });
 function sum(arr: number[]) {
-  return arr.reduce(function(a, b) {
-    return a + b;
-  }, 0);
+    return arr.reduce((a, b) => a + b, 0);
 }
 function max(arr: number[]) {
-  return Math.max.apply(Math, arr);
+    return Math.max.apply(Math, arr);
 }
 
-
 functionExample.addArgument(['integers'], {
-  metavar: 'N',
-  type: 'int',
-  nargs: '+',
-  help: 'an integer for the accumulator'
+    metavar: 'N',
+    type: 'int',
+    nargs: '+',
+    help: 'an integer for the accumulator'
 });
 functionExample.addArgument(['--sum'], {
-  dest: 'accumulate',
-  action: 'storeConst',
-  constant: sum,
-  defaultValue: max,
-  help: 'sum the integers (default: find the max)'
+    dest: 'accumulate',
+    action: 'storeConst',
+    constant: sum,
+    defaultValue: max,
+    help: 'sum the integers (default: find the max)'
 });
 
 args = functionExample.parseArgs('--sum 1 2 -1'.split(' '));
 console.log(args.accumulate(args.integers));
 
-
-
-
-var formatterExample = new ArgumentParser({
-  prog: 'PROG',
-  formatterClass: RawDescriptionHelpFormatter,
-  description: 'Keep the formatting\n' +
-  '    exactly as it is written\n' +
-  '\n' +
-  'here\n'
+const formatterExample = new ArgumentParser({
+    prog: 'PROG',
+    formatterClass: RawDescriptionHelpFormatter,
+    description: 'Keep the formatting\n' +
+    '    exactly as it is written\n' +
+    '\n' +
+    'here\n'
 });
 
 formatterExample.addArgument(['--foo'], {
-  help: '  foo help should not\n' +
-  '    retain this odd formatting'
+    help: '  foo help should not\n' +
+    '    retain this odd formatting'
 });
 
 formatterExample.addArgument(['spam'], {
-  'help': 'spam help'
+    help: 'spam help',
 });
 
-var group = formatterExample.addArgumentGroup({
-  title: 'title',
-  description: '    This text\n' +
-  '  should be indented\n' +
-  '    exactly like it is here\n'
+const group = formatterExample.addArgumentGroup({
+    title: 'title',
+    description: '    This text\n' +
+    '  should be indented\n' +
+    '    exactly like it is here\n'
 });
 
 group.addArgument(['--bar'], {
-  help: 'bar help'
+    help: 'bar help'
 });
 formatterExample.printHelp();

types/argparse/index.d.ts

@@ -1,26 +1,24 @@
-// Type definitions for argparse v1.0
+// Type definitions for argparse 1.0
 // Project: https://github.com/nodeca/argparse
 // Definitions by: Andrew Schurman <https://github.com/arcticwaters>
 //                 Tomasz Łaziuk <https://github.com/tlaziuk>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
-
-export declare class ArgumentParser extends ArgumentGroup {
+export class ArgumentParser extends ArgumentGroup {
     constructor(options?: ArgumentParserOptions);
-
     addSubparsers(options?: SubparserOptions): SubParser;
-    parseArgs(args?: string[], ns?: Namespace | Object): any;
+    parseArgs(args?: string[], ns?: Namespace | object): any;
     printUsage(): void;
     printHelp(): void;
     formatUsage(): string;
     formatHelp(): string;
-    parseKnownArgs(args?: string[], ns?: Namespace | Object): any[];
+    parseKnownArgs(args?: string[], ns?: Namespace | object): any[];
     convertArgLineToArg(argLine: string): string[];
     exit(status: number, message: string): void;
     error(err: string | Error): void;
 }
 
-declare class Namespace {
+export class Namespace {
     constructor(options: object);
     get<K extends keyof this, D extends any>(key: K, defaultValue?: D): this[K] | D;
     isset<K extends keyof this>(key: K): boolean;
@@ -30,11 +28,11 @@ declare class Namespace {
     unset<K extends keyof this, D extends any>(key: K, defaultValue?: D): this[K] | D;
 }
 
-declare class SubParser {
+export class SubParser {
     addParser(name: string, options?: SubArgumentParserOptions): ArgumentParser;
 }
 
-declare class ArgumentGroup {
+export class ArgumentGroup {
     addArgument(args: string[], options?: ArgumentOptions): void;
     addArgumentGroup(options?: ArgumentGroupOptions): ArgumentGroup;
     addMutuallyExclusiveGroup(options?: { required: boolean }): ArgumentGroup;
@@ -42,7 +40,7 @@ declare class ArgumentGroup {
     getDefault(dest: string): any;
 }
 
-interface SubparserOptions {
+export interface SubparserOptions {
     title?: string;
     description?: string;
     prog?: string;
@@ -53,12 +51,12 @@ interface SubparserOptions {
     metavar?: string;
 }
 
-interface SubArgumentParserOptions extends ArgumentParserOptions {
+export interface SubArgumentParserOptions extends ArgumentParserOptions {
     aliases?: string[];
     help?: string;
 }
 
-interface ArgumentParserOptions {
+export interface ArgumentParserOptions {
     description?: string;
     epilog?: string;
     addHelp?: boolean;
@@ -71,19 +69,19 @@ interface ArgumentParserOptions {
     version?: string;
 }
 
-interface ArgumentGroupOptions {
+export interface ArgumentGroupOptions {
     prefixChars?: string;
     argumentDefault?: any;
     title?: string;
     description?: string;
 }
 
-export declare class HelpFormatter { }
-export declare class ArgumentDefaultsHelpFormatter { }
-export declare class RawDescriptionHelpFormatter { }
-export declare class RawTextHelpFormatter { }
+export class HelpFormatter { }
+export class ArgumentDefaultsHelpFormatter { }
+export class RawDescriptionHelpFormatter { }
+export class RawTextHelpFormatter { }
 
-interface ArgumentOptions {
+export interface ArgumentOptions {
     action?: string;
     optionStrings?: string[];
     dest?: string;