update whitespace rules in tslint.json and apply

* curly: true - enforce curly braces on if/while/etc. blocks
* no-consecutive-blank-lines: true
* one-line - make sure { is on the same line
* make sure there is a space before type definitions

Author: nicknisi

src/lib/application.ts

@@ -20,7 +20,6 @@ import {AbstractComponent, ChildableComponent, Component, Option} from './utils/
 import {Options, OptionsReadMode, IOptionsReadResult} from './utils/options/index';
 import {ParameterType} from './utils/options/declaration';
 
-
 /**
  * The default TypeDoc main application class.
  *
@@ -35,63 +34,60 @@ import {ParameterType} from './utils/options/declaration';
  * and emit a series of events while processing the project. Subscribe to these Events
  * to control the application flow or alter the output.
  */
-@Component({name:'application', internal:true})
-export class Application extends ChildableComponent<Application, AbstractComponent<Application>>
-{
-    options:Options;
+@Component({name: 'application', internal: true})
+export class Application extends ChildableComponent<Application, AbstractComponent<Application>> {
+    options: Options;
 
     /**
      * The converter used to create the declaration reflections.
      */
-    converter:Converter;
+    converter: Converter;
 
     /**
      * The renderer used to generate the documentation output.
      */
-    renderer:Renderer;
+    renderer: Renderer;
 
     /**
      * The logger that should be used to output messages.
      */
-    logger:Logger;
+    logger: Logger;
 
-    plugins:PluginHost;
+    plugins: PluginHost;
 
     @Option({
         name: 'logger',
         help: 'Specify the logger that should be used, \'none\' or \'console\'',
         defaultValue: 'console',
         type: ParameterType.Mixed
     })
-    loggerType:string|Function;
+    loggerType: string|Function;
 
     @Option({
         name: 'ignoreCompilerErrors',
         help: 'Should TypeDoc generate documentation pages even after the compiler has returned errors?',
         type: ParameterType.Boolean
     })
-    ignoreCompilerErrors:boolean;
+    ignoreCompilerErrors: boolean;
 
     @Option({
         name: 'exclude',
         help: 'Define a pattern for excluded files when specifying paths.',
         type: ParameterType.String
     })
-    exclude:string;
+    exclude: string;
 
     /**
      * The version number of TypeDoc.
      */
     static VERSION = '{{ VERSION }}';
 
-
-
     /**
      * Create a new TypeDoc application instance.
      *
      * @param options An object containing the options that should be used.
      */
-    constructor(options?:Object) {
+    constructor(options?: Object) {
         super(null);
 
         this.logger    = new ConsoleLogger();
@@ -103,18 +99,17 @@ export class Application extends ChildableComponent<Application, AbstractCompone
         this.bootstrap(options);
     }
 
-
     /**
      * Initialize TypeDoc with the given options object.
      *
      * @param options  The desired options to set.
      */
-    protected bootstrap(options?:Object):IOptionsReadResult {
+    protected bootstrap(options?: Object): IOptionsReadResult {
         this.options.read(options, OptionsReadMode.Prefetch);
 
         const logger = this.loggerType;
         if (typeof logger === 'function') {
-            this.logger = new CallbackLogger(<any>logger);
+            this.logger = new CallbackLogger(<any> logger);
         } else if (logger === 'none') {
             this.logger = new Logger();
         }
@@ -123,42 +118,37 @@ export class Application extends ChildableComponent<Application, AbstractCompone
         return this.options.read(options, OptionsReadMode.Fetch);
     }
 
-
     /**
      * Return the application / root component instance.
      */
-    get application():Application {
+    get application(): Application {
         return this;
     }
 
-
-    get isCLI():boolean {
+    get isCLI(): boolean {
         return false;
     }
 
-
     /**
      * Return the path to the TypeScript compiler.
      */
-    public getTypeScriptPath():string {
+    public getTypeScriptPath(): string {
         return Path.dirname(require.resolve('typescript'));
     }
 
-
-    public getTypeScriptVersion():string {
+    public getTypeScriptVersion(): string {
         const tsPath = this.getTypeScriptPath();
         const json = JSON.parse(FS.readFileSync(Path.join(tsPath, '..', 'package.json'), 'utf8'));
         return json.version;
     }
 
-
     /**
      * Run the converter for the given set of files and return the generated reflections.
      *
      * @param src  A list of source that should be compiled and converted.
      * @returns An instance of ProjectReflection on success, NULL otherwise.
      */
-    public convert(src:string[]):ProjectReflection {
+    public convert(src: string[]): ProjectReflection {
         this.logger.writeln('Using TypeScript %s from %s', this.getTypeScriptVersion(), this.getTypeScriptPath());
 
         const result = this.converter.convert(src);
@@ -175,26 +165,27 @@ export class Application extends ChildableComponent<Application, AbstractCompone
         }
     }
 
-
     /**
      * @param src  A list of source files whose documentation should be generated.
      */
-    public generateDocs(src:string[], out:string):boolean;
+    public generateDocs(src: string[], out: string): boolean;
 
     /**
      * @param project  The project the documentation should be generated for.
      */
-    public generateDocs(project:ProjectReflection, out:string):boolean;
+    public generateDocs(project: ProjectReflection, out: string): boolean;
 
     /**
      * Run the documentation generator for the given set of files.
      *
      * @param out  The path the documentation should be written to.
      * @returns TRUE if the documentation could be generated successfully, otherwise FALSE.
      */
-    public generateDocs(input:any, out:string):boolean {
+    public generateDocs(input: any, out: string): boolean {
         const project = input instanceof ProjectReflection ? input : this.convert(input);
-        if (!project) return false;
+        if (!project) {
+            return false;
+        }
 
         out = Path.resolve(out);
         this.renderer.render(project, out);
@@ -207,26 +198,27 @@ export class Application extends ChildableComponent<Application, AbstractCompone
         return true;
     }
 
-
     /**
      * @param src  A list of source that should be compiled and converted.
      */
-    public generateJson(src:string[], out:string):boolean;
+    public generateJson(src: string[], out: string): boolean;
 
     /**
      * @param project  The project that should be converted.
      */
-    public generateJson(project:ProjectReflection, out:string):boolean;
+    public generateJson(project: ProjectReflection, out: string): boolean;
 
     /**
      * Run the converter for the given set of files and write the reflections to a json file.
      *
      * @param out  The path and file name of the target file.
      * @returns TRUE if the json file could be written successfully, otherwise FALSE.
      */
-    public generateJson(input:any, out:string):boolean {
+    public generateJson(input: any, out: string): boolean {
         const project = input instanceof ProjectReflection ? input : this.convert(input);
-        if (!project) return false;
+        if (!project) {
+            return false;
+        }
 
         out = Path.resolve(out);
         writeFile(out, JSON.stringify(project.toObject(), null, '\t'), false);
@@ -235,7 +227,6 @@ export class Application extends ChildableComponent<Application, AbstractCompone
         return true;
     }
 
-
     /**
      * Expand a list of input files.
      *
@@ -246,13 +237,13 @@ export class Application extends ChildableComponent<Application, AbstractCompone
      * @param inputFiles  The list of files that should be expanded.
      * @returns  The list of input files with expanded directories.
      */
-    public expandInputFiles(inputFiles?:string[]):string[] {
-        let exclude:IMinimatch, files:string[] = [];
+    public expandInputFiles(inputFiles?: string[]): string[] {
+        let exclude: IMinimatch, files: string[] = [];
         if (this.exclude) {
             exclude = new Minimatch(this.exclude);
         }
 
-        function add(dirname:string) {
+        function add(dirname: string) {
             FS.readdirSync(dirname).forEach((file) => {
                 const realpath = Path.join(dirname, file);
                 if (FS.statSync(realpath).isDirectory()) {
@@ -279,7 +270,6 @@ export class Application extends ChildableComponent<Application, AbstractCompone
         return files;
     }
 
-
     /**
      * Print the version number.
      */

src/lib/cli.ts

@@ -6,55 +6,49 @@ import {IOptionsReadResult} from './utils/options/options';
 import {ParameterHint, ParameterType} from './utils/options/declaration';
 import {getOptionsHelp} from './utils/options/help';
 
-
-export const enum ExitCode
-{
+export const enum ExitCode {
     OptionError  = 1,
     NoInputFiles = 2,
     NoOutput     = 3,
     CompileError = 4,
     OutputError  = 5
 }
 
-
-export class CliApplication extends Application
-{
+export class CliApplication extends Application {
     @Option({
         name:  'out',
         help:  'Specifies the location the documentation should be written to.',
         hint:  ParameterHint.Directory
     })
-    out:string;
+    out: string;
 
     @Option({
         name:  'json',
         help:  'Specifies the location and file name a json file describing the project is written to.',
         hint:  ParameterHint.File
     })
-    json:string;
+    json: string;
 
     @Option({
         name:  'version',
         short: 'v',
         help:  'Print the TypeDoc\'s version.',
         type:  ParameterType.Boolean
     })
-    version:boolean;
+    version: boolean;
 
     @Option({
         name:  'help',
         short: 'h',
         help:  'Print this message.',
         type:  ParameterType.Boolean
     })
-    help:boolean;
-
-
+    help: boolean;
 
     /**
      * Run TypeDoc from the command line.
      */
-    protected bootstrap(options?:Object):IOptionsReadResult {
+    protected bootstrap(options?: Object): IOptionsReadResult {
         const result = super.bootstrap(options);
         if (result.hasErrors) {
             process.exit(ExitCode.OptionError);
@@ -75,8 +69,12 @@ export class CliApplication extends Application
             const src = this.expandInputFiles(result.inputFiles);
             const project = this.convert(src);
             if (project) {
-                if (this.out) this.generateDocs(project, this.out);
-                if (this.json) this.generateJson(project, this.json);
+                if (this.out) {
+                    this.generateDocs(project, this.out);
+                }
+                if (this.json) {
+                    this.generateJson(project, this.json);
+                }
                 if (this.logger.hasErrors()) {
                     process.exit(ExitCode.OutputError);
                 }
@@ -88,8 +86,7 @@ export class CliApplication extends Application
         return result;
     }
 
-
-    get isCLI():boolean {
+    get isCLI(): boolean {
         return true;
     }
 }