gigasecond: Initial analyzer (#38)

## Statistics

|               Status | Count | Comments | Unique |    Avg | Median |   Total |
| --------------------:| -----:| --------:| ------:| ------:|-------:|--------:|
|              Approve |    89 |       29 |      4 |  515ms |  605ms |      4s |
|           Disapprove |   234 |       44 |     12 |  482ms |  508ms |     11s |
|      Refer to mentor |   176 |       37 |      4 |  466ms |  485ms |      8s |
|                Total |   499 |       92 |     14 |  482ms |  504ms |     24s |

Author: SleeplessByte

src/analyze.ts

@@ -16,6 +16,7 @@ const { exercise, options, input, logger } = Bootstrap.call()
 
 logger.log('=> DEBUG mode is on')
 logger.log(`=> exercise: ${exercise.slug}`)
+logger.log(`=> options: ${options.pretty ? 'pretty ' : ''}${options.noTemplates ? 'no-templates' : 'templates'} ${options.dry ? 'dry ' : ''}`)
 
 // The autoloader knows where an analyzer should live and tries to require it
 // so it can be instantiated here. This allows us to add new analyzers without

src/analyzers/IsolatedAnalyzerImpl.ts

@@ -0,0 +1,43 @@
+import { getProcessLogger as getLogger, Logger } from '~src/utils/logger'
+
+import { IsolatedAnalyzerOutput, EarlyFinalization } from '~src/output/IsolatedAnalyzerOutput';
+
+export abstract class IsolatedAnalyzerImpl implements Analyzer {
+  protected readonly logger: Logger
+
+  /**
+   * Creates an instance of an analyzer
+   */
+  constructor() {
+    this.logger = getLogger()
+  }
+
+  /**
+   * Runs the analyzer
+   *
+   * This is defined as a property instead of a method, so that it can not be
+   * overriddden in a subclass. Subclasses should override @see execute instead.
+   *
+   * @returns The promise that resolves the analyzer output.
+   *
+   * @memberof BaseAnalyzer
+   */
+  public async run(input: Input): Promise<Output> {
+    const output = new IsolatedAnalyzerOutput()
+    await this.execute(input, output)
+      .catch((err): void | never => {
+        if (err instanceof EarlyFinalization) {
+          this.logger.log(`=> early finialization (${output.status})`)
+        } else {
+          throw err
+        }
+      })
+
+    return output
+  }
+
+  /**
+   * Execute the analyzer
+   */
+  protected abstract execute(input: Input, output: WritableOutput): Promise<void>
+}

src/analyzers/SourceImpl.ts

@@ -0,0 +1,55 @@
+import { TSESTree, AST_NODE_TYPES } from "@typescript-eslint/typescript-estree";
+
+type NodeWithLocation = TSESTree.Node & {
+  range?: TSESTree.Range;
+  loc?: TSESTree.SourceLocation;
+}
+
+interface Source {
+  get(node: NodeWithLocation): string;
+}
+
+class SourceImpl implements Source {
+  private readonly lines: string[]
+
+  constructor(source: string) {
+    this.lines = source.split("\n")
+  }
+
+  public get(node: NodeWithLocation): string {
+    const start = this.lines[node.loc.start.line - 1]
+    const end = this.lines[node.loc.end.line - 1]
+    if (start === end) {
+      return start.substring(node.loc.start.column, node.loc.end.column)
+    }
+
+    return [
+      start.substring(node.loc.start.column),
+      ...this.lines.slice(node.loc.start.line, node.loc.end.line - 2),
+      end.substring(0, node.loc.end.column)
+    ].join("\n")
+  }
+
+  public getOuter(node: NodeWithLocation): string {
+    switch (node.type) {
+      case AST_NODE_TYPES.ArrowFunctionExpression: {
+        return this.get(node).replace(this.get(node.body), '...')
+      }
+      case AST_NODE_TYPES.FunctionDeclaration: {
+        return this.get(node).replace(node.body && this.get(node.body) || '...', '...')
+      }
+      case AST_NODE_TYPES.FunctionExpression: {
+        return this.get(node).replace(node.body && this.get(node.body) || '...', '...')
+      }
+      case AST_NODE_TYPES.VariableDeclaration: {
+        const first = node.declarations[0].init
+        return this.get(node).replace(first && this.get(first) || '...', first && this.getOuter(first) || '...')
+      }
+      default: {
+        return this.get(node)
+      }
+    }
+  }
+}
+
+export { SourceImpl as Source }