feat(dirinfo): added DirInfo class for managing files in memory

Also added the following:
 - Unit tests for DirInfo.
 - Optimized the implementation of FileInfo
and add Unit test.

Author: NoraH1to

__tests__/config.spec.ts

@@ -1,14 +1,18 @@
 import { describe, it, expect } from 'vitest';
 import { Config, defaultRepo } from '@/Config';
-import { useEnvVar } from '@/utils';
-import { getPathnameMapByNameAndExtList } from './helper';
+import {
+  getPathnameMapByNameAndExtList,
+  getTempCacheDirFn,
+  autoClearCacheDir,
+} from './helper';
 import { nanoid } from 'nanoid';
 
 import type { Repository } from '@/Source';
 
-const { __dir_cache_test } = useEnvVar();
+const getTempCacheDir = getTempCacheDirFn('config');
 
 describe('Source', () => {
+  autoClearCacheDir('config');
   let pathnameMap = {
     emptyYml: '',
     hasNotSourceYml: '',
@@ -102,9 +106,9 @@ describe('Source', () => {
   });
 
   it('should generate file after save() called', () => {
-    const configPathname = path.resolve(
-      __dir_cache_test,
-      `./config/${nanoid()}Config.yml`,
+    const configPathname = path.join(
+      getTempCacheDir(),
+      `/${nanoid()}Config.yml`,
     );
 
     expect(fs.existsSync(configPathname)).not.toBeTruthy();

__tests__/dir.spec.ts

@@ -0,0 +1,111 @@
+import { DirInfo } from '@/Dir';
+import { describe, expect, it } from 'vitest';
+import { autoClearCacheDir, getTempCacheDirFn } from './helper';
+import fs from 'fs-extra';
+import { FileInfo } from '@/File';
+
+const getTempCacheDir = getTempCacheDirFn('dir');
+
+describe('Build DirInfo', () => {
+  autoClearCacheDir('dir');
+
+  it('Should work correctly when using unexist paths', () => {
+    const pathname = getTempCacheDir();
+    expect(() => DirInfo.build({ pathname })).not.toThrowError();
+  });
+
+  it('Should work correctly when using exist paths', () => {
+    const pathname = getTempCacheDir(true);
+    fs.ensureDirSync(path.join(pathname, '/subDir'));
+    fs.ensureFileSync(path.join(pathname, '/subDir/content.txt'));
+    expect(() => DirInfo.build({ pathname })).not.toThrowError();
+  });
+
+  it('Should work correctly with cache', () => {
+    const pathname = getTempCacheDir();
+    const infoA = DirInfo.build({ pathname });
+    const infoB = DirInfo.build({ pathname });
+    expect(infoA === infoB).toBeTruthy();
+  });
+});
+
+describe('Get or check item in DirInfo', () => {
+  autoClearCacheDir('dir');
+
+  it('Should has not un-ensure file or dir', () => {
+    const pathname = getTempCacheDir();
+    const dir = DirInfo.build({ pathname });
+
+    expect(dir.exist).not.toBeTruthy();
+    expect(dir.has('/path/no/exist')).not.toBeTruthy();
+    expect(dir.get('/path/no/exist')).not.toBeTruthy();
+  });
+
+  it('Should has exist file or dir', () => {
+    const pathname = getTempCacheDir(true);
+    fs.ensureDirSync(path.join(pathname, '/path/exist'));
+    const dir = DirInfo.build({ pathname });
+
+    expect(dir.exist).toBeTruthy();
+    expect(dir.has('/path/exist')).toBeTruthy();
+    expect(dir.get('/path/exist')).toBeTruthy();
+  });
+
+  it('Should get item with correct type', () => {
+    const pathname = getTempCacheDir();
+    const dir = DirInfo.build({ pathname });
+
+    dir.ensure('/dir', { type: 'dir' });
+    expect(dir.get('/dir') instanceof DirInfo).toBeTruthy();
+
+    dir.ensure('/file', { type: 'file' });
+    expect(dir.get('/file') instanceof FileInfo).toBeTruthy();
+  });
+});
+
+describe('Ensure item in DirInfo', () => {
+  autoClearCacheDir('dir');
+
+  it('Should ensure virtual file or dir', () => {
+    const pathname = getTempCacheDir();
+    const dir = DirInfo.build({ pathname });
+    const subPathname = '/path/no/exist';
+
+    dir.ensure(subPathname, { type: 'dir' });
+
+    expect(dir.has(subPathname)).toBeTruthy();
+    expect(dir.get(subPathname)?.exist).not.toBeTruthy();
+  });
+
+  it('Should get error when ensure duplicate name at the end', () => {
+    const pathname = getTempCacheDir();
+    const dir = DirInfo.build({ pathname });
+
+    dir.ensure('/dir', { type: 'dir' });
+    expect(() => dir.ensure('/dir', { type: 'file' })).toThrowError();
+  });
+
+  it('Should work correctly when ensure same item at the end', () => {
+    const pathname = getTempCacheDir();
+    const dir = DirInfo.build({ pathname });
+
+    dir.ensure('/dir', { type: 'dir' });
+    expect(() => dir.ensure('/dir', { type: 'dir' })).not.toThrowError();
+  });
+
+  it('Should get error when there is an existing file before the end', () => {
+    const pathname = getTempCacheDir();
+    const dir = DirInfo.build({ pathname });
+
+    dir.ensure('/file', { type: 'file' });
+    expect(() => dir.ensure('/file/file', { type: 'file' })).toThrowError();
+  });
+
+  it('Should work correctly when there is an existing folder before the end', () => {
+    const pathname = getTempCacheDir();
+    const dir = DirInfo.build({ pathname });
+
+    dir.ensure('/dir', { type: 'dir' });
+    expect(() => dir.ensure('/dir/file', { type: 'file' })).not.toThrowError();
+  });
+});

__tests__/file.spec.ts

@@ -12,63 +12,73 @@ let pathnameMap = {
   somethingFile: '',
 } as const;
 
-pathnameMap = getPathnameMapByNameAndExtList(['empty', 'something'], ['json', 'yml', 'file'], 'file') as typeof pathnameMap;
+pathnameMap = getPathnameMapByNameAndExtList(
+  ['empty', 'something'],
+  ['json', 'yml', 'file'],
+  'file',
+) as typeof pathnameMap;
 
 describe('FileInfo', () => {
   it('should throw error when pathname is illegal', () => {
-    expect(() => new FileInfo('./illegal.file')).toThrowError();
+    expect(() => FileInfo.build({ pathname: './illegal.file' })).toThrowError();
   });
 
   it('should has empty content and jsonObj when file is empty', () => {
-    let file = new FileInfo(pathnameMap.emptyJson);
+    let file = FileInfo.build({ pathname: pathnameMap.emptyJson });
     expect(file.getContent()).not.toBeTruthy();
     expect(file.getJson()).not.toBeTruthy();
 
-    file = new FileInfo(pathnameMap.emptyYml);
+    file = FileInfo.build({ pathname: pathnameMap.emptyYml });
     expect(file.getContent()).not.toBeTruthy();
     expect(file.getJson()).not.toBeTruthy();
 
-    file = new FileInfo(pathnameMap.emptyFile);
+    file = FileInfo.build({ pathname: pathnameMap.emptyFile });
     expect(file.getContent()).not.toBeTruthy();
     expect(file.getJson()).not.toBeTruthy();
   });
 
   it('should has content when file has content', () => {
-    let file = new FileInfo(pathnameMap.somethingJson);
+    let file = FileInfo.build({ pathname: pathnameMap.somethingJson });
     expect(file.getContent()).toBe('{ "something": "something" }\n');
 
-    file = new FileInfo(pathnameMap.somethingYml);
+    file = FileInfo.build({ pathname: pathnameMap.somethingYml });
     expect(file.getContent()).toBe("something: 'something'\n");
 
-    file = new FileInfo(pathnameMap.somethingFile);
+    file = FileInfo.build({ pathname: pathnameMap.somethingFile });
     expect(file.getContent()).toBe('something\n');
   });
 
   it('should has jsonObj when .yml and .json are not empty', () => {
-    let file = new FileInfo(pathnameMap.somethingJson);
+    let file = FileInfo.build({ pathname: pathnameMap.somethingJson });
     expect(file.getJson()).toEqual({ something: 'something' });
 
-    file = new FileInfo(pathnameMap.somethingYml);
+    file = FileInfo.build({ pathname: pathnameMap.somethingYml });
     expect(file.getJson()).toEqual({ something: 'something' });
   });
 
   it('should has not jsonObj when not .yml and .json', () => {
-    const file = new FileInfo(pathnameMap.somethingFile);
+    const file = FileInfo.build({ pathname: pathnameMap.somethingFile });
     expect(file.getJson()).toBe(undefined);
   });
 
   it('should update jsonObj when content update', () => {
-    let file = new FileInfo(pathnameMap.somethingJson);
+    let file = FileInfo.build({ pathname: pathnameMap.somethingJson });
     file.setContent('{ "something": "newSomething" }');
     expect(file.getJson()).toEqual({ something: 'newSomething' });
 
-    file = new FileInfo(pathnameMap.somethingYml);
+    file = FileInfo.build({ pathname: pathnameMap.somethingYml });
     file.setContent("something: 'newSomething'");
     expect(file.getJson()).toEqual({ something: 'newSomething' });
   });
 
   it('should has not content when file not exist', () => {
-    const file = new FileInfo(path.resolve('unexist.file'));
+    const file = FileInfo.build({ pathname: path.resolve('unexist.file') });
     expect(file.getContent()).toBeUndefined();
   });
+
+  it('should build with cache', () => {
+    const fileA = FileInfo.build({ pathname: path.resolve('file') });
+    const fileB = FileInfo.build({ pathname: path.resolve('file') });
+    expect(fileA === fileB).toBeTruthy();
+  });
 });

__tests__/helper.ts

@@ -1,6 +1,11 @@
 import { TemplateSource } from '@/Source';
 import path from 'path';
 import { fileURLToPath } from 'url';
+import { useEnvVar } from '@/utils';
+import { nanoid } from 'nanoid';
+import { beforeAll, afterAll } from 'vitest';
+
+const { __dir_cache_test } = useEnvVar();
 
 export const getPathnameMapByNameAndExtList = (
   nameList: string[],
@@ -32,11 +37,6 @@ export const getTestTemplateSource = async (name = 'default') =>
         repository: path.resolve(__dirname, './assets/source'),
         type: 'local',
       },
-      {
-        name: `${name}-remote`,
-        repository: 'https://github.com/NoraH1to/setup-template-test.git',
-        type: 'git',
-      },
     ],
   });
 
@@ -50,3 +50,25 @@ export const templateSourcePathnameMap = getPathnameMapByNameAndExtList(
   [''],
   'source',
 );
+
+export const getTempCacheDirFn = (pathname: string) => (ensure?: boolean) => {
+  const target = path.join(__dir_cache_test, pathname, nanoid());
+  ensure && fs.ensureDirSync(target);
+  return target;
+};
+
+export const clearCacheDir = (pathname?: string) => {
+  pathname = path.join(__dir_cache_test, pathname);
+  try {
+    fs.readdirSync(pathname).forEach((name) =>
+      fs.rmSync(path.join(pathname, name), { recursive: true }),
+    );
+  } catch {
+    /* empty */
+  }
+};
+
+export const autoClearCacheDir = (pathname?: string) => {
+  beforeAll(() => clearCacheDir(pathname));
+  afterAll(() => clearCacheDir(pathname));
+};

__tests__/source.spec.ts

@@ -66,8 +66,8 @@ describe('Template source', () => {
   it('should load correct template', async () => {
     const source = await getTestTemplateSource('default');
 
-    expect(source.baseSourceList.length).toBe(3);
-    expect(source.injectSourceList.length).toBe(3);
+    expect(source.baseSourceList.length).toBe(2);
+    expect(source.injectSourceList.length).toBe(2);
 
     expect(source.baseSourceMap['default/has-meta']).toBeTruthy();
     expect(source.baseSourceMap['default/has-not-meta']).toBeTruthy();

package.json

@@ -56,6 +56,7 @@
     "tslib": "^2.4.1",
     "typescript": "^4.9.4",
     "typescript-transform-paths": "^3.4.6",
+    "utility-types": "^3.10.0",
     "vitest": "^0.28.4"
   },
   "dependencies": {

pnpm-lock.yaml

@@ -21,8 +21,8 @@ export const defaultRepo = {
 export class Config extends FileInfo<{
   repository: { [key: string]: Repository };
 }> {
-  constructor(pathname) {
-    super(pathname);
+  constructor(pathname: string) {
+    super({ pathname });
     if (!this.jsonObj) this.jsonObj = { repository: defaultRepo };
     if (!this.jsonObj.repository) this.jsonObj.repository = defaultRepo;
   }