Feature/incremental update (#64)

* Add model initialization, Implement listening for the file changes

* Add an example of the classes layout for adding the incremental update feature

* Add tests for the incremental update feature

* Implement incremental update feature: Use proxy to track entities by file, Add methods to remove obsolete entities and relations

* Change the ts2famix creating file and class code, leave comments regarding this

* Remove unused files

* Add testPathIgnorePatterns into the Jest configuration

* Fix the failing smoke test

* Refactor code for the Famix Class creation (#8)

* Refactor code for the Famic Class creation

* Connect vscode extension with ts2famix changes

* Add neverthrow library, Throw the error when the tsconfig file is not found

* Add better error handling for commands, Add response type for commands

* Add the test cases list

* Rename 'createOrGetFamixClass' method to 'ensureFamixClass' method

* Inheritance incremental update (#20)

* Add the source anchor deletion implementation

* Refactor inheritance and interface creation

* Add a FullyQualifiedNameEntity interface

* Add catching the error for the extension incremental update

* Update README.md

* Split SourcedEntity class into 2 classes: SourcedEntity and EntityWithSourceAnchor

* Properties incremental update (#59)

* Add tests and incremental update for property

* Import clause incremental update new (#58)

* Add the source anchor deletion implementation

* Refactor inheritance and interface creation

* Add a FullyQualifiedNameEntity interface

* Split SourcedEntity class into 2 classes: SourcedEntity and EntityWithSourceAnchor

* Add tests for import clause

* Implement ImportClause for named imports. Add incremental update for the imported entities (Inheritance and ImportClause).
----------------------------
Still need to resolve the issue with:
- re-export
- the cases when we choose to create the module over a file
- finish file and module Famix elements creation, add tests
- implement ImportClause for other types of imports

* Add reexport tests

* Add namespace import tests

* Add implementation for the Import Clause for
- named import/export;
- namespace import/export;
- reexport.
Encapsulate ImportClause creation logic in a separate file

* Add test with exporting interfaces for the inheritance

* Remove the old ImportClause test

* Fix getFamixEntityByFullyQualifiedName to work with all the entities that have fullyQualifiedName field

* Fix getModuleSpecifierFromDeclaration to work with import without ts. We still need to verify how does it work with node_modules and import aliases

* Add excluding files specified in tsconfig from watching

* Add tests for incremental update of adding types

* Incremental update cleanup (#63)

* Review and fix tests

Author: norilanda

jest.config.json

@@ -7,5 +7,9 @@
     "^.+\\.tsx?$": ["ts-jest", { }]
   },
   "testEnvironment": "jest-environment-node",
-  "verbose": true
+  "verbose": true,
+  "testPathIgnorePatterns": [
+    "/node_modules/",
+    "/vscode-extension/"
+  ]
 }

src/analyze.ts

@@ -1,13 +1,24 @@
-import { Project } from "ts-morph";
+import { Project, SourceFile } from "ts-morph";
 import * as fs from 'fs';
 import { FamixRepository } from "./lib/famix/famix_repository";
 import { Logger } from "tslog";
 import { EntityDictionary, EntityDictionaryConfig } from "./famix_functions/EntityDictionary";
 import path from "path";
 import { TypeScriptToFamixProcessor  } from "./analyze_functions/process_functions";
+import { getFamixIndexFileAnchorFileName } from "./helpers";
+import { isSourceFileAModule } from "./famix_functions/helpersTsMorphElementsProcessing";
+import { FamixBaseElement } from "./lib/famix/famix_base_element";
+import { getDirectDependentAssociations, getSourceFilesToUpdate, removeDependentAssociations } from "./helpers";
+import { getTransientDependentEntities } from "./helpers/transientDependencyResolverHelper";
 
 export const logger = new Logger({ name: "ts2famix", minLevel: 2 });
 
+export enum SourceFileChangeType {
+    Create = 0,
+    Update = 1,
+    Delete = 2,
+}
+
 /**
  * This class is used to build a Famix model from a TypeScript source code
  */
@@ -59,20 +70,16 @@ export class Importer {
     private processEntities(project: Project): void {
         const onlyTypeScriptFiles = project.getSourceFiles().filter(f => f.getFilePath().endsWith('.ts'));
         this.processFunctions.processFiles(onlyTypeScriptFiles);
-        const accesses = this.processFunctions.accessMap;
-        const methodsAndFunctionsWithId = this.processFunctions.methodsAndFunctionsWithId;
-        const classes = this.processFunctions.classes;
-        const interfaces = this.processFunctions.interfaces;
-        const modules = this.processFunctions.modules;
-        const exports = this.processFunctions.listOfExportMaps;
-
-        this.processFunctions.processImportClausesForImportEqualsDeclarations(project.getSourceFiles(), exports);
-        this.processFunctions.processImportClausesForModules(modules, exports);
-        this.processFunctions.processAccesses(accesses);
-        this.processFunctions.processInvocations(methodsAndFunctionsWithId);
-        this.processFunctions.processInheritances(classes, interfaces);
-        this.processFunctions.processConcretisations(classes, interfaces, methodsAndFunctionsWithId);
+        
+        this.processReferences(onlyTypeScriptFiles, onlyTypeScriptFiles);
+    }
 
+    private processReferences(sourceFiles: SourceFile[], allExistingSourceFiles: SourceFile[]): void {        
+        // TODO: process Access, Invocations, Concretisations
+        this.processFunctions.processImportClausesForImportEqualsDeclarations(allExistingSourceFiles);
+        
+        const modules = sourceFiles.filter(f => isSourceFileAModule(f));
+        this.processFunctions.processImportClausesForModules(modules);
     }
 
     /**
@@ -103,13 +110,47 @@ export class Importer {
 
         //const famixRep = this.famixRepFromPaths(sourceFileNames);
 
+        this.project = project;
         this.initFamixRep(project);
 
         this.processEntities(project);
 
         return this.entityDictionary.famixRep;
     }
 
+    public updateFamixModelIncrementally(sourceFileChangeMap: Map<SourceFileChangeType, SourceFile[]>): void {
+        const allChangedSourceFiles = Array.from(sourceFileChangeMap.values()).flat();
+
+        const removedEntities: FamixBaseElement[] = [];
+        allChangedSourceFiles.forEach(
+            file => {
+                const filePath = getFamixIndexFileAnchorFileName(file.getFilePath(), this.entityDictionary.getAbsolutePath());
+                const removed = this.entityDictionary.famixRep.removeEntitiesBySourceFile(filePath);
+                removedEntities.push(...removed);
+            }
+        );
+
+        const allSourceFiles = this.project.getSourceFiles();
+        const directDependentAssociations = getDirectDependentAssociations(removedEntities);
+        const transientDependentAssociations = getTransientDependentEntities(this.entityDictionary, sourceFileChangeMap);
+
+        const associationsToRemove = [...directDependentAssociations, ...transientDependentAssociations];
+
+        removeDependentAssociations(this.entityDictionary.famixRep, associationsToRemove);
+
+        const sourceFilesToEnsure = getSourceFilesToUpdate(
+            associationsToRemove, sourceFileChangeMap, allSourceFiles, this.entityDictionary.getAbsolutePath()
+        );
+
+        this.processFunctions.processFiles(sourceFilesToEnsure);
+        const sourceFilesToDelete = sourceFileChangeMap.get(SourceFileChangeType.Delete) || [];
+        const existingSourceFiles = allSourceFiles.filter(
+            file => !sourceFilesToDelete.includes(file)
+        );
+        this.processReferences(sourceFilesToEnsure, existingSourceFiles);
+
+    }
+
     private initFamixRep(project: Project): void {
         // get compiler options
         const compilerOptions = project.getCompilerOptions();