feat: WIP added ability to delete a resource from an existing file

Author: kevinwang5658

package-lock.json

@@ -10,12 +10,12 @@
     "@oclif/core": "^4.0.8",
     "@oclif/plugin-help": "^6.2.4",
     "@oclif/plugin-update": "^4.6.13",
-    "@types/diff": "^7.0.1",
     "ajv": "^8.12.0",
     "ajv-formats": "^3.0.1",
     "chalk": "^5.3.0",
     "codify-schemas": "^1.0.63",
     "debug": "^4.3.4",
+    "detect-indent": "^7.0.1",
     "diff": "^7.0.0",
     "ink": "^5",
     "jotai": "^2.11.1",
@@ -34,6 +34,7 @@
     "@oclif/prettier-config": "^0.2.1",
     "@types/chalk": "^2.2.0",
     "@types/debug": "^4.1.12",
+    "@types/diff": "^7.0.1",
     "@types/js-yaml": "^4.0.9",
     "@types/mocha": "^10.0.10",
     "@types/node": "^20",

package.json

@@ -1,8 +1,12 @@
-import { describe, it, vi, afterEach } from 'vitest';
-import { FileModificationCalculator, ModificationType } from './file-modification-calculator';
-import { ResourceConfig } from '../entities/resource-config';
-import { ResourceInfo } from '../entities/resource-info';
-import { FileType, InMemoryFile } from '../parser/entities';
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+
+import { describe, it, vi, afterEach, expect } from 'vitest';
+import { FileModificationCalculator, ModificationType } from './file-modification-calculator.js';
+import { ResourceConfig } from '../entities/resource-config.js';
+import { ResourceInfo } from '../entities/resource-info.js';
+import { CodifyParser } from '../parser/index.js';
 
 vi.mock('node:fs', async () => {
   const { fs } = await import('memfs');
@@ -14,39 +18,133 @@ vi.mock('node:fs/promises', async () => {
   return fs.promises;
 })
 
+const defaultPath = '/codify.json'
+
 
 describe('File modification calculator tests', () => {
 
   it('Can generate a diff and a new file', async () => {
-    const existingResource = new ResourceConfig({
-      type: 'resource1'
+    const existingFile =
+`[
+  {
+		"type": "project",
+		"plugins": {
+			"default": "latest"
+		}
+	},
+	{ "type": "resource1", "param2": ["a", "b", "c"]}
+]`
+    generateTestFile(existingFile);
+
+    const project = await CodifyParser.parse(defaultPath)
+    project.resourceConfigs.forEach((r) => {
+      r.attachResourceInfo(generateResourceInfo(r.type))
     });
-    existingResource.attachResourceInfo(generateResourceInfo('resource1'))
 
-    const existingFileContents =
+    const modifiedResource = new ResourceConfig({
+      type: 'resource1',
+      parameter1: 'abc'
+    })
+    modifiedResource.attachResourceInfo(generateResourceInfo('resource1'))
+
+    const calculator = new FileModificationCalculator(project.resourceConfigs, project.sourceMaps.getSourceMap(defaultPath).file, project.sourceMaps);
+    const result = await calculator.calculate([{
+      modification: ModificationType.INSERT_OR_UPDATE,
+      resource: modifiedResource,
+    }])
+
+    console.log(result)
+    console.log(result.diff)
+  })
+
+  it('Can delete a resource from an existing config (with proper commas)', async () => {
+    const existingFile =
 `[
   {
     "type": "project",
     "plugins": {
-      "default": "latest",
+      "default": "latest"
     }
   },
-  { "type": "resource1" }
+  { 
+    "type": "resource1",
+    "param2": ["a", "b", "c"]
+  }
 ]`
-    const existingFile = <InMemoryFile> { filePath: '/path/to/file.json', fileType: FileType.JSON, contents: existingFileContents };
+    generateTestFile(existingFile);
+
+    const project = await CodifyParser.parse(defaultPath)
+    project.resourceConfigs.forEach((r) => {
+      r.attachResourceInfo(generateResourceInfo(r.type))
+    });
 
     const modifiedResource = new ResourceConfig({
       type: 'resource1',
       parameter1: 'abc'
     })
     modifiedResource.attachResourceInfo(generateResourceInfo('resource1'))
 
-    const calculator = new FileModificationCalculator([existingResource], existingFile)
+    const calculator = new FileModificationCalculator(project.resourceConfigs, project.sourceMaps.getSourceMap(defaultPath).file, project.sourceMaps);
     const result = await calculator.calculate([{
-      modification: ModificationType.INSERT_OR_UPDATE,
+      modification: ModificationType.DELETE,
       resource: modifiedResource,
     }])
 
+    expect(result.newFile).to.eq('[\n' +
+      '  {\n' +
+      '    "type": "project",\n' +
+      '    "plugins": {\n' +
+      '      "default": "latest"\n' +
+      '    }\n' +
+      '  }\n' +
+      '  \n' +
+      ']')
+    console.log(result)
+    console.log(result.diff)
+  })
+
+  it('Can delete a resource from an existing config 2 (with proper commas)', async () => {
+    const existingFile =
+      `[
+  { 
+    "type": "resource1",
+    "param2": ["a", "b", "c"]
+  },
+  {
+    "type": "project",
+    "plugins": {
+      "default": "latest"
+    }
+  }
+]`
+    generateTestFile(existingFile);
+
+    const project = await CodifyParser.parse(defaultPath)
+    project.resourceConfigs.forEach((r) => {
+      r.attachResourceInfo(generateResourceInfo(r.type))
+    });
+
+    const modifiedResource = new ResourceConfig({
+      type: 'resource1',
+      parameter1: 'abc'
+    })
+    modifiedResource.attachResourceInfo(generateResourceInfo('resource1'))
+
+    const calculator = new FileModificationCalculator(project.resourceConfigs, project.sourceMaps.getSourceMap(defaultPath).file, project.sourceMaps);
+    const result = await calculator.calculate([{
+      modification: ModificationType.DELETE,
+      resource: modifiedResource,
+    }])
+
+    // expect(result.newFile).to.eq('[\n' +
+    //   '  {\n' +
+    //   '    "type": "project",\n' +
+    //   '    "plugins": {\n' +
+    //   '      "default": "latest"\n' +
+    //   '    }\n' +
+    //   '  }\n' +
+    //   '  \n' +
+    //   ']')
     console.log(result)
     console.log(result.diff)
   })
@@ -63,3 +161,10 @@ function generateResourceInfo(type: string, requiredParameters?: string[]): Reso
     import: { requiredParameters }
   })
 }
+
+/**
+ * To generate the source maps and parsed resources it's easier to write it to the file-system and parse it for real
+ */
+function generateTestFile(contents: string, filePath = defaultPath): void {
+  fs.writeFileSync(filePath, contents, { encoding: 'utf8' });
+}

src/utils/file-modification-calculator.test.ts

@@ -2,6 +2,8 @@ import chalk from 'chalk';
 import { ResourceConfig } from '../entities/resource-config.js';
 import * as Diff from 'diff'
 import { FileType, InMemoryFile } from '../parser/entities.js';
+import { SourceLocation, SourceMapCache } from '../parser/source-maps.js';
+import detectIndent from 'detect-indent';
 
 export enum ModificationType {
   INSERT_OR_UPDATE,
@@ -21,10 +23,12 @@ export interface FileModificationResult {
 export class FileModificationCalculator {
   private existingFile?: InMemoryFile;
   private existingResources: ResourceConfig[];
+  private sourceMaps: SourceMapCache;
 
-  constructor(existingResources: ResourceConfig[], existingFile: InMemoryFile) {
+  constructor(existingResources: ResourceConfig[], existingFile: InMemoryFile, sourceMaps: SourceMapCache) {
     this.existingFile = existingFile;
     this.existingResources = existingResources;
+    this.sourceMaps = sourceMaps;
   }
 
   async calculate(modifications: ModifiedResource[]): Promise<FileModificationResult> {
@@ -44,41 +48,49 @@ export class FileModificationCalculator {
     }
 
     this.validate(modifications);
+    const { sourceMap, file } = this.sourceMaps.getSourceMap('/codify.json')!;
+    const fileIndents = detectIndent(file.contents);
+    const indentString = fileIndents.indent;
 
-    for (const modified of modifications) {
+    let newFile = file.contents.trimEnd();
+
+    console.log(JSON.stringify(sourceMap, null, 2))
+
+    // Reverse the traversal order so we edit from the back. This way the line numbers won't be messed up with new edits.
+    for (const modified of modifications.reverse()) {
       const duplicateIndex = this.existingResources.findIndex((existing) => existing.isSameOnSystem(modified.resource))
 
       if (duplicateIndex === -1) {
         if (modified.modification === ModificationType.INSERT_OR_UPDATE) {
-          resultResources.push(modified.resource);
+          const config = JSON.stringify(modified.resource.raw, null, indentString)
+          newFile = this.insertConfig(newFile, config, indentString);
         }
 
         continue;
       }
 
+      const duplicate = this.existingResources[duplicateIndex];
+      const duplicateSourceKey = duplicate.sourceMapKey?.split('#').at(1)!;
+
       if (modified.modification === ModificationType.DELETE) {
-        resultResources.splice(duplicateIndex, 1);
+        const { value, valueEnd } = sourceMap.lookup(duplicateSourceKey)!
+
+        newFile = this.remove(newFile, value, valueEnd);
         continue;
-      }
 
-      const duplicate = resultResources[duplicateIndex];
-      for (const [key, newValue] of Object.entries(modified.resource.parameters)) {
-        duplicate.setParameter(key, newValue);
       }
-    }
 
-    const newFile = JSON.stringify(
-      resultResources.map((r) => r.raw),
-      null, 2
-    );
+      resultResources.splice(duplicateIndex, 1, modified.resource);
+    }
 
     return {
-      newFile,
+      newFile: newFile,
       diff: this.diff(this.existingFile.contents, newFile),
     }
   }
 
   validate(modifiedResources: ModifiedResource[]): void {
+    // The result of the validation rules only apply if we want to insert into a file. If it's a new file nothing is really needed
     if (!this.existingFile) {
       return;
     }
@@ -102,6 +114,10 @@ export class FileModificationCalculator {
 
       throw new Error(`All resources must have resource info attached to generate diff. Found bad resources: ${badResources}`);
     }
+
+    if (!this.sourceMaps) {
+      throw new Error('Source maps must be provided to generate new code');
+    }
   }
 
   diff(a: string, b: string): string {
@@ -116,4 +132,54 @@ export class FileModificationCalculator {
 
     return result;
   }
+
+  // Insert always works at the end
+  private insertConfig(
+    file: string,
+    config: string,
+    indentString: string,
+  ) {
+    const configWithIndents = config.split(/\n/).map((l) => `${indentString}l`).join('\n');
+    const result = file.substring(0, configWithIndents.length - 1) + ',' + configWithIndents + file.at(-1);
+
+    // Need to fix the position of the comma
+
+    return result;
+  }
+
+  private remove(
+    file: string,
+    value: SourceLocation,
+    valueEnd: SourceLocation,
+  ): string {
+    let result = file.substring(0, value.position) + file.substring(valueEnd.position)
+
+    let commaIndex = - 1;
+    for (let counter = value.position; counter > 0; counter--) {
+      if (result[counter] === ',') {
+        commaIndex = counter;
+        break;
+      }
+    }
+
+    // Not able to find comma behind (this was the first element). We want to delete the comma behind then.
+    if (commaIndex === -1) {
+      for (let counter = value.position; counter < file.length - 1; counter++) {
+        if (result[counter] === ',') {
+          commaIndex = counter;
+          break;
+        }
+      }
+    }
+
+    if (commaIndex !== -1) {
+      result = this.splice(result, commaIndex, 1)
+    }
+
+    return result;
+  }
+
+  private splice(s: string, start: number, deleteCount = 0, insert = '') {
+    return s.substring(0, start) + insert + s.substring(start + deleteCount);
+  }
 }