Merge pull request #12 from TinkoffCreditSystems/ng-morph-tree

Ng morph tree

Author: IKatsuba

libs/ng-morph/project/classes/devkit-file-system.ts

@@ -23,7 +23,7 @@ import { DirectoryEntry, FileSystem } from './file-system';
 export class DevkitFileSystem extends FileSystem {
   private _updateRecorderCache = new Map<string, UpdateRecorder>();
 
-  constructor(private _tree: Tree) {
+  constructor(readonly tree: Tree) {
     super();
   }
 
@@ -36,13 +36,13 @@ export class DevkitFileSystem extends FileSystem {
     if (this._updateRecorderCache.has(filePath)) {
       return this._updateRecorderCache.get(filePath) as UpdateRecorder;
     }
-    const recorder = this._tree.beginUpdate(filePath);
+    const recorder = this.tree.beginUpdate(filePath);
     this._updateRecorderCache.set(filePath, recorder);
     return recorder;
   }
 
   commitEdits() {
-    this._updateRecorderCache.forEach((r) => this._tree.commitUpdate(r));
+    this._updateRecorderCache.forEach((r) => this.tree.commitUpdate(r));
     this._updateRecorderCache.clear();
   }
 
@@ -51,7 +51,7 @@ export class DevkitFileSystem extends FileSystem {
     // directory exists. It throws a specific error though if a directory
     // is being read as a file. We use that to check if a directory exists.
     try {
-      return this._tree.get(fileOrDirPath) !== null;
+      return this.tree.get(fileOrDirPath) !== null;
     } catch (e) {
       if (e instanceof PathIsDirectoryException) {
         return true;
@@ -61,25 +61,25 @@ export class DevkitFileSystem extends FileSystem {
   }
 
   overwrite(filePath: Path, content: string) {
-    this._tree.overwrite(filePath, content);
+    this.tree.overwrite(filePath, content);
   }
 
   create(filePath: Path, content: string) {
-    this._tree.create(filePath, content);
+    this.tree.create(filePath, content);
   }
 
   delete(filePath: Path) {
-    this._tree.delete(filePath);
+    this.tree.delete(filePath);
   }
 
   read(filePath: Path) {
-    const buffer = this._tree.read(filePath);
+    const buffer = this.tree.read(filePath);
     return buffer !== null ? buffer.toString() : null;
   }
 
   readDirectory(dirPath: Path): DirectoryEntry {
     try {
-      const { subdirs: directories, subfiles: files } = this._tree.getDir(
+      const { subdirs: directories, subfiles: files } = this.tree.getDir(
         dirPath
       );
       return { directories, files };

libs/ng-morph/project/classes/file-system.ts

@@ -10,6 +10,7 @@ import { UpdateRecorder } from './update-recorder';
 import { FileSystemHost } from 'ts-morph';
 import { basename, join } from 'path';
 import * as miltimatch from 'multimatch';
+import { DevkitFileSystem } from './devkit-file-system';
 
 /**
  * A workspace path semantically is equivalent to the `Path` type provided by the
@@ -87,7 +88,7 @@ export abstract class FileSystem {
 }
 
 export class NgCliFileSystem implements FileSystemHost {
-  constructor(public fs: FileSystem) {}
+  constructor(public fs: DevkitFileSystem) {}
 
   async copy(srcPath: string, destPath: string): Promise<void> {
     this.copySync(srcPath, destPath);

libs/ng-morph/project/classes/ng-cli-project.ts

@@ -2,6 +2,7 @@ import { Project } from 'ts-morph';
 import { NgCliProjectOptions } from '../types/ng-cli-project-options';
 import { DevkitFileSystem } from './devkit-file-system';
 import { NgCliFileSystem } from './file-system';
+import { NgMorphTree } from './ng-morph-tree';
 
 export class NgCliProject extends Project {
   constructor({ host, ...options }: NgCliProjectOptions) {
@@ -14,4 +15,22 @@ export class NgCliProject extends Project {
   getFileSystem(): NgCliFileSystem {
     return super.getFileSystem() as NgCliFileSystem;
   }
+
+  async save(): Promise<void> {
+    await super.save();
+    await this.trySaveTree();
+  }
+
+  saveSync() {
+    super.saveSync();
+    this.trySaveTree();
+  }
+
+  private async trySaveTree(): Promise<void> {
+    const tree = this.getFileSystem().fs.tree;
+
+    if (tree instanceof NgMorphTree) {
+      return tree.commitChanges();
+    }
+  }
 }

libs/ng-morph/project/classes/ng-morph-tree.spec.ts

@@ -1,7 +1,13 @@
 import { Tree } from '@angular-devkit/schematics';
-import { NgMorphTree } from 'ng-morph/project/classes/ng-morph-tree';
-import { createProject, setActiveProject } from 'ng-morph/project';
-import { getSourceFile } from 'ng-morph/source-file';
+import { NgMorphTree } from './ng-morph-tree';
+import {
+  createProject,
+  saveActiveProject,
+  setActiveProject,
+} from 'ng-morph/project';
+import { createSourceFile, getSourceFile } from 'ng-morph/source-file';
+import * as fs from 'fs';
+import { join } from 'path';
 
 describe('NgMorphTree', () => {
   let tree: Tree;
@@ -18,16 +24,44 @@ describe('NgMorphTree', () => {
 
   it('should read from fs', () => {
     expect(getSourceFile('/ng-morph-tree.ts')?.getFullText())
-      .toStrictEqual(`import { HostTree } from '@angular-devkit/schematics';
+      .toStrictEqual(`import { HostSink, HostTree } from '@angular-devkit/schematics';
 import { ScopedHost } from '@angular-devkit/core/src/virtual-fs/host';
 import { NodeJsSyncHost } from '@angular-devkit/core/node';
 import { normalize } from '@angular-devkit/core';
 
 export class NgMorphTree extends HostTree {
+  private hostSink: HostSink;
+
   constructor(root: string = process.cwd()) {
-    super(new ScopedHost(new NodeJsSyncHost(), normalize(root)));
+    const host = new ScopedHost(new NodeJsSyncHost(), normalize(root));
+    super(host);
+
+    this.hostSink = new HostSink(host);
+  }
+
+  commitChanges(): Promise<void> {
+    return this.hostSink.commit(this).toPromise();
   }
 }
 `);
   });
+
+  it('should write to fs', () => {
+    createSourceFile('__file.ts', `content`, { overwrite: true });
+
+    const spy = jest.spyOn(fs, 'writeFileSync');
+
+    spy.mockImplementationOnce(() => {
+      // empty
+    });
+
+    saveActiveProject();
+
+    expect(spy).toHaveBeenCalledWith(
+      join(__dirname, '__file.ts'),
+      Uint8Array.from([99, 111, 110, 116, 101, 110, 116])
+    );
+
+    spy.mockRestore();
+  });
 });

libs/ng-morph/project/classes/ng-morph-tree.ts

@@ -1,10 +1,19 @@
-import { HostTree } from '@angular-devkit/schematics';
+import { HostSink, HostTree } from '@angular-devkit/schematics';
 import { ScopedHost } from '@angular-devkit/core/src/virtual-fs/host';
 import { NodeJsSyncHost } from '@angular-devkit/core/node';
 import { normalize } from '@angular-devkit/core';
 
 export class NgMorphTree extends HostTree {
+  private hostSink: HostSink;
+
   constructor(root: string = process.cwd()) {
-    super(new ScopedHost(new NodeJsSyncHost(), normalize(root)));
+    const host = new ScopedHost(new NodeJsSyncHost(), normalize(root));
+    super(host);
+
+    this.hostSink = new HostSink(host);
+  }
+
+  commitChanges(): Promise<void> {
+    return this.hostSink.commit(this).toPromise();
   }
 }

libs/ng-morph/source-file/helpers/create-source-file.ts

@@ -3,7 +3,8 @@ import { SourceFile } from 'ts-morph';
 
 export function createSourceFile(
   filePath: string,
-  content?: string
+  content?: string,
+  { overwrite = false }: { overwrite?: boolean } = {}
 ): SourceFile {
-  return getActiveProject().createSourceFile(filePath, content);
+  return getActiveProject().createSourceFile(filePath, content, { overwrite });
 }