feat(rework): new layout

Author: MeirionHughes

source/ast.ts

@@ -4,59 +4,3 @@ export * from './ast/ast-element-node';
 export * from './ast/ast-location';
 export * from './ast/ast-node';
 export * from './ast/ast-text-node';
-
-import { ASTElementAttribute } from './ast/ast-element-attribute';
-import { ASTElementNode } from './ast/ast-element-node';
-import { ASTTextNode } from './ast/ast-text-node';
-import { ASTLocation } from './ast/ast-location';
-import { ASTNode } from './ast/ast-node';
-import { ParserTask } from './parser-task';
-import { Parser } from './parser';
-
-export class ASTGen extends ParserTask {
-  public root: ASTNode = null;
-
-  constructor() { super(); }
-
-  init(parser: Parser, path?: string) {
-
-    var current = this.root = new ASTNode();
-
-    parser.on("startTag", (tag, attrs, selfClosing, loc) => {
-      let next = new ASTElementNode();
-      next.tag = tag;
-      next.parent = current;
-      next.location = <ASTLocation>{ start: loc.startOffset, end: loc.endOffset, line: loc.line, column: loc.col, path: path };
-      next.attrs = attrs.map((x, i) => {
-        var attr = new ASTElementAttribute();
-
-        attr.name = (x.prefix !== undefined && x.prefix != "") ? `${x.prefix}:${x.name}` : x.name;
-
-        var attrLoc = loc.attrs[attr.name] || loc.attrs[attr.name.toLowerCase()];
-
-        if (attrLoc == undefined)
-          attrLoc = { startOffset: -1, endOffset: -1, line: -1, col: -1 };
-
-        attr.location = <ASTLocation>{ start: attrLoc.startOffset, end: attrLoc.endOffset, line: attrLoc.line, column: attrLoc.col, path: path };
-
-        return attr;
-      });
-
-      current.children.push(next);
-
-      if (!parser.isVoid(tag))
-        current = next;
-    });
-
-    parser.on("endTag", (tag, attrs, selfClosing, loc) => {
-      current = current.parent;
-    });
-
-    parser.on("text", (text, loc) => {
-      let child = new ASTTextNode();
-      child.parent = current;
-      child.location = <ASTLocation>{ start: loc.startOffset, end: loc.endOffset, line: loc.line, column: loc.col, path: path };
-      current.children.push(child);
-    });
-  }
-}

source/ast/ast-element-node.ts

@@ -1,11 +1,14 @@
 import { ASTNode } from './ast-node';
 import { ASTElementAttribute } from './ast-element-attribute';
+import { ClassDeclaration } from 'typescript';
 
 export class ASTElementNode extends ASTNode {
-  public tag: string;
+  public name: string;
   public namespace?: string;
   public attrs: ASTElementAttribute[];
-
+  public typeValue: HTMLElement; 
+  public typeDecl: ClassDeclaration;
+  
   constructor() {
     super();
   }

source/file-analyser.ts

@@ -0,0 +1,29 @@
+import { File } from './file';
+import { FileTask } from './file-task';
+
+export class FileAnalyser {
+  private chain: FileTask[];
+
+  constructor() {
+    this.chain = [];
+  }
+  
+  use(task: FileTask) {    
+    this.chain.push(task);
+  }
+
+  async analyse(file: File): Promise<File> {
+    file = {
+      content: file.content,
+      kind: file.kind,
+      path: file.path
+    };
+
+    for (var task of this.chain) {
+      let final = await task.process(file);
+      if (final)
+        break;
+    }
+    return file;
+  }
+}

source/file-kind.ts

@@ -0,0 +1,4 @@
+export enum FileKind{
+  Source,
+  Html
+}

source/file-result.ts

@@ -0,0 +1,25 @@
+import { File } from './file';
+import { FileTask } from './file-task';
+
+export class FileTaskChain implements FileTask {
+  private chain: FileTask[];
+  public isFinal: boolean;
+
+  constructor() {
+    this.chain = [];
+    this.isFinal = false;
+  }
+
+  use(task: FileTask) {
+    this.chain.push(task);
+  }
+
+  async process(file: File): Promise<boolean> {
+    for (var task of this.chain) {
+      let final = await task.process(file);
+      if (final)
+        break;
+    }
+    return this.isFinal;
+  }
+}

source/file-task-chain.ts

@@ -0,0 +1,9 @@
+import { File } from './file';
+
+export interface FileTask {
+  /**
+   * process and argment the file
+   * @returns whether the process finalised the file
+   */
+  process(file: File): Promise<boolean>;
+}

source/file-task.ts

@@ -1,4 +1,16 @@
-export interface File {
+import { Issue } from "./issue";
+import { ASTNode } from "./ast";
+import { File } from './file';
+import { FileKind } from './file-kind';
+export { FileKind } from './file-kind';
+
+export interface File {  
   content: string;
+  kind: FileKind;
+
   path?: string;
+
+  ext?: string;
+  issues?: Issue[];  
+  imports?: string[];
 }

source/file.ts

@@ -1,7 +1,5 @@
 export * from './ast';
 export * from './issue';
-export * from './linter';
-export * from './parser';
-export * from './parser-state';
-export * from './parser-task';
-export * from './reflection';
+export * from './file';
+export * from './file-task';
+export * from './file-analyser';

source/index.ts

@@ -0,0 +1,13 @@
+/** 
+ * Issue Severity
+ */
+export enum IssueSeverity {
+  /* information on a better way */
+  Info = 0,
+  /* an issue that may result in odd results */
+  Warning = 1,
+  /* an issue that will result in missing/broken content */
+  Error = 2,
+  /* an issue that breaks the entire document/template */
+  Fatal = 3
+}

source/issue-severity.ts

@@ -1,3 +1,5 @@
+import { IssueSeverity } from './issue-severity';
+export { IssueSeverity } from './issue-severity';
 /**
 * information about an issue
 */
@@ -11,16 +13,3 @@ export interface Issue {
   detail?: string;
 }
 
-/** 
- * Issue Severity
- */
-export enum IssueSeverity {
-  /* information on a better way */
-  Info = 0,
-  /* an issue that may result in odd results */
-  Warning = 1,
-  /* an issue that will result in missing/broken content */
-  Error = 2,
-  /* an issue that breaks the entire document/template */
-  Fatal = 3
-}

source/issue.ts

@@ -0,0 +1,3 @@
+export interface Options
+{
+}

source/options.ts

@@ -0,0 +1,30 @@
+import {ParserFileTask} from './tasks/parser-file-task';
+import {FileTaskChain} from './file-task-chain';
+import {Project} from './project';
+import {Options} from './options';
+
+export class ProjectBuilder{
+  build(opts: Options): Project{
+    opts = opts || {};
+
+    var project = new Project();
+
+    project.use(this.buildHtmlChain(opts));
+
+    return project;
+  }
+
+  private buildHtmlChain(opts: Options){
+    var chain = new FileTaskChain();
+
+    chain.use(this.buildHtmlParser(opts));
+
+    return chain;
+  }
+
+
+  private buildHtmlParser(opts: Options){
+    var parser = new ParserFileTask(opts);
+    return parser;
+  }
+}

source/parser-task.ts

@@ -0,0 +1,26 @@
+import { SourceReflection } from './reflection/source-reflection';
+import { AureliaReflection } from './reflection/aurelia-reflection';
+import { FileAnalyser } from './file-analyser';
+import { FileTask } from './file-task';
+import { File } from './file';
+import * as path from 'path';
+
+export class Project {
+  private aureliaReflection: AureliaReflection;
+  private sourceReflection: SourceReflection;
+  private analyser: FileAnalyser;
+
+  constructor() {
+    this.aureliaReflection = new AureliaReflection();
+    this.sourceReflection = new SourceReflection();
+    let analyser = new FileAnalyser();
+  }
+
+  use(task: FileTask) {
+    this.analyser.use(task);
+  }
+
+  async process(file: File): Promise<File> {
+    return await this.analyser.analyse(file);
+  }
+}

source/project-builder.ts

@@ -4,9 +4,9 @@ import * as glob from "glob";
 import * as fs from "fs";
 
 /*
-* Manage Reflection information for available sources
+* Manage Source Reflection information for available sources
 */
-export class Reflection {
+export class SourceReflection {
   public sourceFiles: ts.SourceFile[] = [];
   public pathToSource = {};
 

source/project.ts

@@ -0,0 +1,23 @@
+import { FileTask } from '../file-task';
+import { File } from '../file';
+import { Options } from '../options';
+import { Parser } from './parser/parser';
+import { ParserState } from './parser/parser-state';
+import { ParserHook } from './parser/parser-hook';
+import { ASTGenerator } from './parser/hooks/ast-generator';
+
+export class ParserFileTask implements FileTask {
+  constructor(private opts: Options){    
+  }
+
+  async process(file: File): Promise<boolean> {
+
+    var parserState = new ParserState();
+    var parser = new Parser(parserState);
+    var hooks = [new ASTGenerator(this.opts)];
+
+    await parser.process(file, hooks);
+    
+    return false;
+  }
+}