feat: Improved path resource by finally modifying it to search through user files for paths instead of spewing everything in path. Fixed tests and improved git clone to have a better matcher

Author: kevinwang5658

package.json

@@ -23,7 +23,7 @@
     "ajv": "^8.12.0",
     "ajv-formats": "^2.1.1",
     "semver": "^7.6.0",
-    "codify-plugin-lib": "1.0.148",
+    "codify-plugin-lib": "1.0.156",
     "codify-schemas": "1.0.63",
     "chalk": "^5.3.0",
     "debug": "^4.3.4",
@@ -50,7 +50,7 @@
     "@types/debug": "4.1.12",
     "@types/plist": "^3.0.5",
     "@types/lodash.isequal": "^4.5.8",
-    "codify-plugin-test": "0.0.47",
+    "codify-plugin-test": "0.0.49",
     "commander": "^12.1.0",
     "eslint": "^8.51.0",
     "eslint-config-oclif": "^5",

src/resources/git/clone/git-clone.ts

@@ -1,10 +1,9 @@
-import { CreatePlan, DestroyPlan, getPty, Resource, ResourceSettings } from 'codify-plugin-lib';
+import { CreatePlan, DestroyPlan, Resource, ResourceSettings, getPty } from 'codify-plugin-lib';
 import { ResourceConfig } from 'codify-schemas';
 import path from 'node:path';
 
 import { codifySpawn } from '../../../utils/codify-spawn.js';
 import { FileUtils } from '../../../utils/file-utils.js';
-import { untildify } from '../../../utils/untildify.js';
 import Schema from './git-clone-schema.json';
 
 
@@ -29,7 +28,22 @@ export class GitCloneResource extends Resource<GitCloneConfig> {
         requiredParameters: ['directory']
       },
       allowMultiple: {
-        identifyingParameters: ['repository'],
+        matcher: (desired, current) => {
+          const desiredPath = desired.parentDirectory
+            ? path.resolve(desired.parentDirectory, this.extractBasename(desired.repository!)!)
+            : path.resolve(desired.directory!);
+
+          const currentPath = current.parentDirectory
+            ? path.resolve(current.parentDirectory, this.extractBasename(current.repository!)!)
+            : path.resolve(current.directory!);
+
+          const isNotCaseSensitive = process.platform === 'darwin';
+          if (isNotCaseSensitive) {
+            return desiredPath.toLowerCase() === currentPath.toLowerCase()
+          }
+ 
+          return desiredPath === currentPath;
+        }
       },
       dependencies: [
         'ssh-key',

src/resources/shell/path/path-resource.test.ts

@@ -0,0 +1,97 @@
+import { describe, expect, it } from 'vitest';
+import { PathResource } from './path-resource';
+
+describe('PathResource unit tests', () => {
+  it('Can match path declarations', () => {
+    const pathResource = new PathResource();
+
+    const result = pathResource.findAllPathDeclarations(
+`
+# bun completions
+[ -s "/Users/kevinwang/.bun/_bun" ] && source "/Users/kevinwang/.bun/_bun"
+
+# bun
+export BUN_INSTALL="$HOME/.bun"
+export PATH="$BUN_INSTALL/bin:$PATH"
+
+export DENO_INSTALL="/Users/kevinwang/.deno"
+export PATH="$DENO_INSTALL/bin:$PATH"
+
+export PATH="$HOME/.jenv/bin:$PATH"
+eval "$(jenv init -)"
+
+export ANDROID_SDK_ROOT="$HOME/Library/Android/sdk"
+`)
+
+    console.log(result);
+
+    expect(result).toMatchObject([
+      {
+        declaration: 'export PATH="$BUN_INSTALL/bin:$PATH"',
+        path: '$BUN_INSTALL/bin'
+      },
+      {
+        declaration: 'export PATH="$DENO_INSTALL/bin:$PATH"',
+        path: '$DENO_INSTALL/bin'
+      },
+      {
+        declaration: 'export PATH="$HOME/.jenv/bin:$PATH"',
+        path: '$HOME/.jenv/bin'
+      }
+    ])
+
+  })
+
+  it('Can match path declarations 2', () => {
+    const pathResource = new PathResource();
+
+    const result = pathResource.findAllPathDeclarations(
+      `
+export NVM_DIR="$HOME/.nvm"
+[ -s "$NVM_DIR/nvm.sh" ] && \\. "$NVM_DIR/nvm.sh"  # This loads nvm
+[ -s "$NVM_DIR/bash_completion" ] && \\. "$NVM_DIR/bash_completion"  # This loads nvm bash_completion
+
+export PYENV_ROOT="$HOME/.pyenv"
+[[ -d $PYENV_ROOT/bin ]] && export PATH="$PYENV_ROOT/bin:$PATH"
+eval "$(pyenv init -)"
+
+alias gcc='git commit -v'
+`)
+
+    expect(result).toMatchObject([
+      {
+        declaration: "export PATH=\"$PYENV_ROOT/bin:$PATH\"",
+        path: "$PYENV_ROOT/bin",
+      }
+    ])
+
+  })
+
+  it('Can match path declarations 3', () => {
+    const pathResource = new PathResource();
+
+    const result = pathResource.findAllPathDeclarations(
+      `
+export PATH=/Users/kevinwang/a/random/path:$PATH;
+export PATH=/Users/kevinwang/.nvm/.bin/2:$PATH;
+export PATH=/Users/kevinwang/.nvm/.bin/3:$PATH;
+`);
+
+    expect(result).toMatchObject([
+      {
+        declaration: 'export PATH=/Users/kevinwang/a/random/path:$PATH;',
+        path: '/Users/kevinwang/a/random/path'
+      },
+      {
+        declaration: 'export PATH=/Users/kevinwang/.nvm/.bin/2:$PATH;',
+        path: '/Users/kevinwang/.nvm/.bin/2'
+      },
+      {
+        declaration: 'export PATH=/Users/kevinwang/.nvm/.bin/3:$PATH;',
+        path: '/Users/kevinwang/.nvm/.bin/3'
+      }
+    ])
+
+  })
+
+})

src/resources/shell/path/path-resource.ts

@@ -3,7 +3,7 @@ import {
   DestroyPlan,
   getPty,
   ModifyPlan,
-  ParameterChange,
+  ParameterChange, RefreshContext, resolvePathWithVariables,
   Resource,
   ResourceSettings
 } from 'codify-plugin-lib';
@@ -20,26 +20,44 @@ export interface PathConfig extends StringIndexedObject {
   path: string;
   paths: string[];
   prepend: boolean;
+  declarationsOnly: boolean;
 }
 
 export class PathResource extends Resource<PathConfig> {
+  private readonly PATH_DECLARATION_REGEX = /((export PATH=)|(path+=\()|(path=\())(.+?)[\n;]/g;
+  private readonly PATH_REGEX = /(?<=[="':(])([^"'\n\r]+?)(?=["':)\n;])/g
+  private readonly filePaths = [
+    path.join(os.homedir(), '.zshrc'),
+    path.join(os.homedir(), '.zprofile'),
+    path.join(os.homedir(), '.zshenv'),
+  ]
+
   getSettings(): ResourceSettings<PathConfig> {
     return {
       id: 'path',
       schema: Schema,
       parameterSettings: {
         path: { type: 'directory' },
         paths: { canModify: true, type: 'array', itemType: 'directory' },
-        prepend: { default: false }
+        prepend: { default: false, setting: true },
+        declarationsOnly: { default: false, setting: true },
       },
       importAndDestroy:{
-        refreshKeys: ['paths'],
+        refreshKeys: ['paths', 'declarationsOnly'],
         defaultRefreshValues: {
-          paths: []
+          paths: [],
+          declarationsOnly: true,
         }
       },
       allowMultiple: {
-        identifyingParameters: ['path', 'paths']
+        matcher: (desired, current) => {
+          if (desired.path) {
+            return desired.path === current.path;
+          }
+
+          const currentPaths = new Set(current.paths)
+          return desired.paths?.some((p) => currentPaths.has(p));
+        }
       }
     }
   }
@@ -50,11 +68,47 @@ export class PathResource extends Resource<PathConfig> {
     }
   }
 
-  override async refresh(parameters: Partial<PathConfig>): Promise<Partial<PathConfig> | null> {
-    const $ = getPty();
+  override async refresh(parameters: Partial<PathConfig>, context: RefreshContext<PathConfig>): Promise<Partial<PathConfig> | null> {
+    // If declarations only, we only look into files to find potential paths
+    if (parameters.declarationsOnly || context.isStateful) {
+      const pathsResult = new Set<string>();
+
+      for (const path of this.filePaths) {
+        if (!(await FileUtils.fileExists(path))) {
+          continue;
+        }
+
+        const contents = await fs.readFile(path, 'utf8');
+        const pathDeclarations = this.findAllPathDeclarations(contents);
 
+        if (parameters.path && pathDeclarations.some((d) => resolvePathWithVariables(untildify(d.path)) === parameters.path)) {
+          return parameters;
+        }
+
+        if (parameters.paths) {
+          pathDeclarations
+            .map((d) => d.path)
+            .forEach((d) => pathsResult.add(resolvePathWithVariables(untildify(d))));
+        }
+      }
+
+      if (parameters.path || pathsResult.size === 0) {
+        return null;
+      }
+
+      return {
+        ...parameters,
+        paths: [...pathsResult],
+      }
+    }
+
+    // Otherwise look in path variable to see if it exists
+    const $ = getPty();
     const { data: existingPaths } = await $.spawnSafe('echo $PATH')
-    if (parameters.path !== undefined && (existingPaths.includes(parameters.path) || existingPaths.includes(untildify(parameters.path)))) {
+
+    if (parameters.path !== undefined && (
+      existingPaths.includes(parameters.path)
+    )) {
       return parameters;
     }
 
@@ -73,8 +127,8 @@ export class PathResource extends Resource<PathConfig> {
     const userPaths = existingPaths.split(':')
       .filter((p) => !systemPaths.includes(p))
 
-    if (parameters.paths !== undefined) {
-      return { paths: userPaths, prepend: parameters.prepend };
+    if (parameters.paths && userPaths.length > 0) {
+      return { ...parameters, paths: userPaths };
     }
 
     return null;
@@ -131,68 +185,63 @@ export class PathResource extends Resource<PathConfig> {
   }
 
   private async removePath(pathValue: string): Promise<void> {
-    const fileInfo = await this.findPathDeclaration(pathValue);
-    if (!fileInfo) {
+    const foundPaths = await this.findPath(pathValue);
+    if (foundPaths.length === 0) {
       throw new Error(`Could not find path declaration: ${pathValue}. Please manually remove the path and then re-run Codify`);
     }
 
-    const { content, pathsFound, filePath } = fileInfo;
-
-    const fileLines = content
-      .split(/\n/);
+    for (const foundPath of foundPaths) {
+      console.log(`Removing path: ${pathValue} from ${foundPath.file}`)
+      await FileUtils.removeFromFile(foundPath.file, foundPath.pathDeclaration.declaration);
+    }
+  }
 
-    for (const pathFound of pathsFound) {
-      const line = fileLines
-        .findIndex((l) => l.includes(pathFound));
+  private async findPath(pathToFind: string): Promise<Array<{ file: string; pathDeclaration: PathDeclaration }>> {
+    const result = [];
 
-      if (line === -1) {
-        throw new Error(`Could not find path declaration: ${pathValue}. Please manually remove the path and then re-run Codify`);
+    for (const filePath of this.filePaths) {
+      if (!(await FileUtils.fileExists(filePath))) {
+        continue;
       }
 
-      fileLines.splice(line, 1);
+      const contents = await fs.readFile(filePath, 'utf8');
+      const pathDeclarations = this.findAllPathDeclarations(contents);
+
+      const foundDeclarations = pathDeclarations.filter((d) => d.path === pathToFind);
+      result.push(...foundDeclarations.map((d) => ({ pathDeclaration: d, file: filePath })));
     }
 
-    console.log(`Removing path: ${pathValue} from ${filePath}`)
-    await fs.writeFile(filePath, fileLines.join('\n'), { encoding: 'utf8' });
+    return result;
   }
 
-  private async findPathDeclaration(value: string): Promise<PathDeclaration | null> {
-    const filePaths = [
-      path.join(os.homedir(), '.zshrc'),
-      path.join(os.homedir(), '.zprofile'),
-      path.join(os.homedir(), '.zshenv'),
-    ];
-
-    const searchTerms = [
-      `export PATH=${value}:$PATH`,
-      `export PATH=$PATH:${value}`,
-      `path+=('${value}')`,
-      `path+=(${value})`,
-      `path=('${value}' $path)`,
-      `path=(${value} $path)`
-    ]
-
-    for (const filePath of filePaths) {
-      if (await FileUtils.fileExists(filePath)) {
-        const fileContents = await fs.readFile(filePath, 'utf8');
-
-        const pathsFound = searchTerms.filter((st) => fileContents.includes(st));
-        if (pathsFound.length > 0) {
-          return {
-            filePath,
-            content: fileContents,
-            pathsFound,
-          }
+  findAllPathDeclarations(contents: string): PathDeclaration[] {
+    const results = [];
+    const pathDeclarations = contents.matchAll(this.PATH_DECLARATION_REGEX);
+
+    for (const declaration of pathDeclarations) {
+      const trimmedDeclaration = declaration[0];
+      const paths = trimmedDeclaration.matchAll(this.PATH_REGEX);
+
+      for (const path of paths) {
+        const trimmedPath = path[0];
+        if (trimmedPath === '$PATH') {
+          continue;
         }
+
+        results.push({
+          declaration: trimmedDeclaration.trim(),
+          path: trimmedPath,
+        });
       }
     }
 
-    return null;
+    return results;
   }
 }
 
 interface PathDeclaration {
-  filePath: string;
-  content: string;
-  pathsFound: string[];
+  // The entire declaration. Ex for: export PATH="$PYENV_ROOT/bin:$PATH", it's export PATH="$PYENV_ROOT/bin:$PATH"
+  declaration: string;
+  // The path being added. Ex for: export PATH="$PYENV_ROOT/bin:$PATH", it's $PYENV_ROOT/bin
+  path: string;
 }

src/resources/shell/path/path-schema.json

@@ -19,6 +19,11 @@
     "prepend": {
       "type": "boolean",
       "description": "Whether or not to prepend to the path."
+    },
+    "declarationsOnly": {
+      "type": "boolean",
+      "default": false,
+      "description": "Only plan and manage explicitly declared paths found in shell startup scripts. This value is forced to true for stateful mode"
     }
   },
   "additionalProperties": false