diff --git a/dist/index.js b/dist/index.js index f9e0b645..84f31c3b 100644 Binary files a/dist/index.js and b/dist/index.js differ diff --git a/dist/index.js.map b/dist/index.js.map index 909edcd7..ce2ebca1 100644 Binary files a/dist/index.js.map and b/dist/index.js.map differ diff --git a/src/__tests__/utils.test.ts b/src/__tests__/utils.test.ts new file mode 100644 index 00000000..f4e2d481 --- /dev/null +++ b/src/__tests__/utils.test.ts @@ -0,0 +1,425 @@ +import {ChangeTypeEnum} from '../changedFiles' +import { + getDirname, + getDirnameMaxDepth, + getFilteredChangedFiles, + normalizeSeparators +} from '../utils' + +const originalPlatform = process.platform + +function mockedPlatform(platform: string): void { + Object.defineProperty(process, 'platform', { + value: platform + }) +} + +describe('utils test', () => { + afterEach(() => { + Object.defineProperty(process, 'platform', { + value: originalPlatform + }) + }) + + describe('getDirnameMaxDepth_function', () => { + // Tests that the function returns the correct dirname when the relative path has multiple directories + it('test_multiple_directories', () => { + const result = getDirnameMaxDepth({ + relativePath: 'path/to/some/file', + dirNamesMaxDepth: 2, + excludeCurrentDir: false + }) + expect(result).toEqual('path/to') + }) + + // Tests that the function returns the correct dirname when the relative path has only one directory + it('test_single_directory', () => { + const result = getDirnameMaxDepth({ + relativePath: 'path/to', + dirNamesMaxDepth: 1, + excludeCurrentDir: false + }) + expect(result).toEqual('path') + }) + + // Tests that the function returns the correct dirname when the relative path has no directories + it('test_no_directories', () => { + const result = getDirnameMaxDepth({ + relativePath: 'file.txt', + dirNamesMaxDepth: 1, + excludeCurrentDir: false + }) + expect(result).toEqual('.') + }) + + // Tests that the function returns the correct dirname when dirNamesMaxDepth is set to a value less than the number of directories in the relative path + it('test_dirnames_max_depth_less_than_num_directories', () => { + const result = getDirnameMaxDepth({ + relativePath: 'path/to/some/file', + dirNamesMaxDepth: 1, + excludeCurrentDir: false + }) + expect(result).toEqual('path') + }) + + // Tests that the function returns an empty string when excludeCurrentDir is true and the output is '.' + it('test_exclude_current_dir_is_true_and_output_is_dot', () => { + const result = getDirnameMaxDepth({ + relativePath: '.', + dirNamesMaxDepth: 1, + excludeCurrentDir: true + }) + expect(result).toEqual('') + }) + + // Tests that the function returns the correct dirname when the relative path is a Windows drive root and excludeCurrentDir is true + it('test_windows_drive_root_and_exclude_current_dir_is_true', () => { + const result = getDirnameMaxDepth({ + relativePath: 'C:\\', + dirNamesMaxDepth: 1, + excludeCurrentDir: true + }) + expect(result).toEqual('') + }) + + // Tests that getDirnameMaxDepth handles a relative path with a trailing separator correctly + it('test_trailing_separator', () => { + const input = { + relativePath: 'path/to/dir/', + dirNamesMaxDepth: 2, + excludeCurrentDir: true + } + const expectedOutput = 'path/to' + const actualOutput = getDirnameMaxDepth(input) + expect(actualOutput).toEqual(expectedOutput) + }) + + // Tests that getDirnameMaxDepth returns an empty string when excludeCurrentDir is true and the output is '.' + it('test_trailing_separator_exclude_current_dir', () => { + const input = { + relativePath: 'file', + excludeCurrentDir: true + } + const expectedOutput = '' + const actualOutput = getDirnameMaxDepth(input) + expect(actualOutput).toEqual(expectedOutput) + }) + + // Tests that getDirnameMaxDepth returns the correct output for a Windows UNC root path + it('test_windows_unc_root', () => { + const input = { + relativePath: '\\hello', + dirNamesMaxDepth: 2, + excludeCurrentDir: true + } + const expectedOutput = '' + expect(getDirnameMaxDepth(input)).toEqual(expectedOutput) + }) + + // Tests that getDirnameMaxDepth returns an empty string when given a Windows UNC root and excludeCurrentDir is true + it('test_windows_unc_root_exclude_current_dir', () => { + const relativePath = '\\hello' + const result = getDirnameMaxDepth({ + relativePath, + excludeCurrentDir: true + }) + expect(result).toEqual('') + }) + + // Tests that getDirnameMaxDepth returns the correct dirname with a relative path that contains both forward and backward slashes + it('test_relative_path_with_slashes', () => { + const relativePath = 'path/to\file' + const expectedOutput = 'path' + const actualOutput = getDirnameMaxDepth({relativePath}) + expect(actualOutput).toEqual(expectedOutput) + }) + + // Tests that getDirnameMaxDepth returns the correct dirname for a relative path that contains special characters + it('test_special_characters', () => { + const relativePath = + 'path/with/special/characters/!@#$%^&*()_+{}|:<>?[];,./' + const expectedDirname = 'path/with/special/characters' + const actualDirname = getDirnameMaxDepth({relativePath}) + expect(actualDirname).toEqual(expectedDirname) + }) + }) + + describe('getDirname_function', () => { + // Tests that the function returns the correct dirname for a valid path + it('test valid path', () => { + expect(getDirname('/path/to/file')).toEqual('/path/to') + }) + + // Tests that the function returns the correct dirname for a valid Windows UNC root path + it('test windows unc root path', () => { + expect(getDirname('\\helloworld')).toEqual('.') + }) + + // Tests that the function returns the correct dirname for a path with a trailing slash + it('test path with trailing slash', () => { + expect(getDirname('/path/to/file/')).toEqual('/path/to') + }) + + // Tests that the function returns the correct dirname for a Windows UNC root path with a trailing slash + it('test windows unc root path with trailing slash', () => { + expect(getDirname('\\hello\\world\\')).toEqual('.') + }) + + // Tests that the function returns the correct dirname for a path with multiple slashes + it('test path with multiple slashes', () => { + expect(getDirname('/path//to/file')).toEqual('/path/to') + }) + + // Tests that the function returns the correct dirname for a Windows UNC root path with multiple slashes + it('test windows unc root path with multiple slashes', () => { + expect(getDirname('\\hello\\world')).toEqual('.') + }) + }) + + describe('normalizeSeparators_function', () => { + // Tests that forward slashes are normalized on Linux + it('test forward slashes linux', () => { + const input = 'path/to/file' + const expectedOutput = 'path/to/file' + const actualOutput = normalizeSeparators(input) + expect(actualOutput).toEqual(expectedOutput) + }) + + // Tests that backslashes are normalized on Windows + it('test backslashes windows', () => { + mockedPlatform('win32') + const input = 'path\\to\\file' + const expectedOutput = 'path\\to\\file' + const actualOutput = normalizeSeparators(input) + expect(actualOutput).toEqual(expectedOutput) + }) + + // Tests that mixed slashes are normalized on Windows + it('test mixed slashes windows', () => { + mockedPlatform('win32') + const input = 'path\\to/file' + const expectedOutput = 'path\\to\\file' + const actualOutput = normalizeSeparators(input) + expect(actualOutput).toEqual(expectedOutput) + }) + + // Tests that an empty string returns an empty string + it('test empty string', () => { + const input = '' + const expectedOutput = '' + const actualOutput = normalizeSeparators(input) + expect(actualOutput).toEqual(expectedOutput) + }) + + // Tests that multiple consecutive slashes are removed + it('test multiple consecutive slashes', () => { + const input = 'path//to//file' + const expectedOutput = 'path/to/file' + const actualOutput = normalizeSeparators(input) + expect(actualOutput).toEqual(expectedOutput) + }) + + // Tests that UNC format is preserved on Windows + it('test unc format windows', () => { + const input = '\\\\hello\\world' + const expectedOutput = '\\\\hello\\world' + const actualOutput = normalizeSeparators(input) + expect(actualOutput).toEqual(expectedOutput) + }) + + // Tests that a drive root is preserved on Windows + it('test drive root windows', () => { + const input = 'C:\\' + const expectedOutput = 'C:\\' + const actualOutput = normalizeSeparators(input) + expect(actualOutput).toEqual(expectedOutput) + }) + }) + + // Generated by CodiumAI + + describe('getFilteredChangedFiles', () => { + // Tests that the function returns an empty object when allDiffFiles and filePatterns are empty + it('should return an empty object when allDiffFiles and filePatterns are empty', async () => { + const result = await getFilteredChangedFiles({ + allDiffFiles: { + [ChangeTypeEnum.Added]: [], + [ChangeTypeEnum.Copied]: [], + [ChangeTypeEnum.Deleted]: [], + [ChangeTypeEnum.Modified]: [], + [ChangeTypeEnum.Renamed]: [], + [ChangeTypeEnum.TypeChanged]: [], + [ChangeTypeEnum.Unmerged]: [], + [ChangeTypeEnum.Unknown]: [] + }, + filePatterns: [] + }) + expect(result).toEqual({ + [ChangeTypeEnum.Added]: [], + [ChangeTypeEnum.Copied]: [], + [ChangeTypeEnum.Deleted]: [], + [ChangeTypeEnum.Modified]: [], + [ChangeTypeEnum.Renamed]: [], + [ChangeTypeEnum.TypeChanged]: [], + [ChangeTypeEnum.Unmerged]: [], + [ChangeTypeEnum.Unknown]: [] + }) + }) + + // Tests that the function returns allDiffFiles when filePatterns is empty + it('should return allDiffFiles when filePatterns is empty', async () => { + const allDiffFiles = { + [ChangeTypeEnum.Added]: ['file1.txt'], + [ChangeTypeEnum.Copied]: [], + [ChangeTypeEnum.Deleted]: [], + [ChangeTypeEnum.Modified]: [], + [ChangeTypeEnum.Renamed]: [], + [ChangeTypeEnum.TypeChanged]: [], + [ChangeTypeEnum.Unmerged]: [], + [ChangeTypeEnum.Unknown]: [] + } + const result = await getFilteredChangedFiles({ + allDiffFiles, + filePatterns: [] + }) + expect(result).toEqual(allDiffFiles) + }) + + // Tests that the function returns an empty object when allDiffFiles is empty + it('should return an empty object when allDiffFiles is empty', async () => { + const result = await getFilteredChangedFiles({ + allDiffFiles: { + [ChangeTypeEnum.Added]: [], + [ChangeTypeEnum.Copied]: [], + [ChangeTypeEnum.Deleted]: [], + [ChangeTypeEnum.Modified]: [], + [ChangeTypeEnum.Renamed]: [], + [ChangeTypeEnum.TypeChanged]: [], + [ChangeTypeEnum.Unmerged]: [], + [ChangeTypeEnum.Unknown]: [] + }, + filePatterns: ['*.txt'] + }) + expect(result).toEqual({ + [ChangeTypeEnum.Added]: [], + [ChangeTypeEnum.Copied]: [], + [ChangeTypeEnum.Deleted]: [], + [ChangeTypeEnum.Modified]: [], + [ChangeTypeEnum.Renamed]: [], + [ChangeTypeEnum.TypeChanged]: [], + [ChangeTypeEnum.Unmerged]: [], + [ChangeTypeEnum.Unknown]: [] + }) + }) + + // Tests that the function returns only the files that match the file patterns + it('should return only the files that match the file patterns', async () => { + const allDiffFiles = { + [ChangeTypeEnum.Added]: ['file1.txt', 'file2.md', 'file3.txt'], + [ChangeTypeEnum.Copied]: [], + [ChangeTypeEnum.Deleted]: [], + [ChangeTypeEnum.Modified]: [], + [ChangeTypeEnum.Renamed]: [], + [ChangeTypeEnum.TypeChanged]: [], + [ChangeTypeEnum.Unmerged]: [], + [ChangeTypeEnum.Unknown]: [] + } + const result = await getFilteredChangedFiles({ + allDiffFiles, + filePatterns: ['*.txt'] + }) + expect(result).toEqual({ + [ChangeTypeEnum.Added]: ['file1.txt', 'file3.txt'], + [ChangeTypeEnum.Copied]: [], + [ChangeTypeEnum.Deleted]: [], + [ChangeTypeEnum.Modified]: [], + [ChangeTypeEnum.Renamed]: [], + [ChangeTypeEnum.TypeChanged]: [], + [ChangeTypeEnum.Unmerged]: [], + [ChangeTypeEnum.Unknown]: [] + }) + }) + + // Tests that the function returns an empty object when there are no files that match the file patterns + it('should return an empty object when there are no files that match the file patterns', async () => { + const allDiffFiles = { + [ChangeTypeEnum.Added]: ['file1.md', 'file2.md', 'file3.md'], + [ChangeTypeEnum.Copied]: [], + [ChangeTypeEnum.Deleted]: [], + [ChangeTypeEnum.Modified]: [], + [ChangeTypeEnum.Renamed]: [], + [ChangeTypeEnum.TypeChanged]: [], + [ChangeTypeEnum.Unmerged]: [], + [ChangeTypeEnum.Unknown]: [] + } + const result = await getFilteredChangedFiles({ + allDiffFiles, + filePatterns: ['*.txt'] + }) + expect(result).toEqual({ + [ChangeTypeEnum.Added]: [], + [ChangeTypeEnum.Copied]: [], + [ChangeTypeEnum.Deleted]: [], + [ChangeTypeEnum.Modified]: [], + [ChangeTypeEnum.Renamed]: [], + [ChangeTypeEnum.TypeChanged]: [], + [ChangeTypeEnum.Unmerged]: [], + [ChangeTypeEnum.Unknown]: [] + }) + }) + + // Tests that the function can handle file names with special characters + it('should handle file names with special characters', async () => { + const allDiffFiles = { + [ChangeTypeEnum.Added]: [ + 'file1.txt', + 'file2 with spaces.txt', + 'file3$$.txt' + ], + [ChangeTypeEnum.Copied]: [], + [ChangeTypeEnum.Deleted]: [], + [ChangeTypeEnum.Modified]: [], + [ChangeTypeEnum.Renamed]: [], + [ChangeTypeEnum.TypeChanged]: [], + [ChangeTypeEnum.Unmerged]: [], + [ChangeTypeEnum.Unknown]: [] + } + const result = await getFilteredChangedFiles({ + allDiffFiles, + filePatterns: ['file2*.txt'] + }) + expect(result).toEqual({ + [ChangeTypeEnum.Added]: ['file2 with spaces.txt'], + [ChangeTypeEnum.Copied]: [], + [ChangeTypeEnum.Deleted]: [], + [ChangeTypeEnum.Modified]: [], + [ChangeTypeEnum.Renamed]: [], + [ChangeTypeEnum.TypeChanged]: [], + [ChangeTypeEnum.Unmerged]: [], + [ChangeTypeEnum.Unknown]: [] + }) + }) + + // Tests that getFilteredChangedFiles correctly filters files using glob patterns + it('should filter files using glob patterns', async () => { + const allDiffFiles = { + [ChangeTypeEnum.Added]: ['test/migrations/test.sql'], + [ChangeTypeEnum.Copied]: [], + [ChangeTypeEnum.Deleted]: [], + [ChangeTypeEnum.Modified]: [], + [ChangeTypeEnum.Renamed]: [], + [ChangeTypeEnum.TypeChanged]: [], + [ChangeTypeEnum.Unmerged]: [], + [ChangeTypeEnum.Unknown]: [] + } + const filePatterns = ['test/migrations/**'] + const filteredFiles = await getFilteredChangedFiles({ + allDiffFiles, + filePatterns + }) + expect(filteredFiles[ChangeTypeEnum.Added]).toEqual([ + 'test/migrations/test.sql' + ]) + }) + }) +}) diff --git a/src/changedFiles.ts b/src/changedFiles.ts index 8e6c1650..974dafda 100644 --- a/src/changedFiles.ts +++ b/src/changedFiles.ts @@ -166,15 +166,15 @@ function* getChangeTypeFilesGenerator({ }): Generator { for (const changeType of changeTypes) { const files = changedFiles[changeType] || [] - for (const file of files) { + for (const filePath of files) { if (inputs.dirNames) { yield getDirnameMaxDepth({ - pathStr: file, + relativePath: filePath, dirNamesMaxDepth: inputs.dirNamesMaxDepth, excludeCurrentDir: inputs.dirNamesExcludeCurrentDir }) } else { - yield file + yield filePath } } } @@ -213,15 +213,15 @@ function* getAllChangeTypeFilesGenerator({ inputs: Inputs changedFiles: ChangedFiles }): Generator { - for (const file of flatten(Object.values(changedFiles))) { + for (const filePath of flatten(Object.values(changedFiles))) { if (inputs.dirNames) { yield getDirnameMaxDepth({ - pathStr: file, + relativePath: filePath, dirNamesMaxDepth: inputs.dirNamesMaxDepth, excludeCurrentDir: inputs.dirNamesExcludeCurrentDir }) } else { - yield file + yield filePath } } } diff --git a/src/utils.ts b/src/utils.ts index fc9aea0d..c57ba838 100644 --- a/src/utils.ts +++ b/src/utils.ts @@ -12,17 +12,20 @@ import {ChangedFiles, ChangeTypeEnum} from './changedFiles' import {Inputs} from './inputs' -const IS_WINDOWS = process.platform === 'win32' const MINIMUM_GIT_VERSION = '2.18.0' +export const isWindows = (): boolean => { + return process.platform === 'win32' +} + /** - * Normalize file path separators to '/' on Windows and Linux/macOS - * @param p file path + * Normalize file path separators to '/' on Linux/macOS and '\\' on Windows + * @param p - file path * @returns file path with normalized separators */ -const normalizeSeparators = (p: string): string => { +export const normalizeSeparators = (p: string): string => { // Windows - if (IS_WINDOWS) { + if (isWindows()) { // Convert slashes on Windows p = p.replace(/\//g, '\\') @@ -35,9 +38,18 @@ const normalizeSeparators = (p: string): string => { return p.replace(/\/\/+/g, '/') } +/** + * Normalize file path separators to '/' on all platforms + * @param p - file path + * @returns file path with normalized separators + */ +const normalizePath = (p: string): string => { + return p.replace(/\\/g, '/') +} + /** * Trims unnecessary trailing slash from file path - * @param p file path + * @param p - file path * @returns file path without unnecessary trailing slash */ const safeTrimTrailingSeparator = (p: string): string => { @@ -60,7 +72,7 @@ const safeTrimTrailingSeparator = (p: string): string => { } // On Windows, avoid trimming the drive root, e.g. C:\ or \\hello - if (IS_WINDOWS && /^[A-Z]:\\$/i.test(p)) { + if (isWindows() && /^[A-Z]:\\$/i.test(p)) { return p } @@ -68,12 +80,18 @@ const safeTrimTrailingSeparator = (p: string): string => { return p.substring(0, p.length - 1) } -const dirname = (p: string): string => { +/** + * Gets the dirname of a path, similar to the Node.js path.dirname() function except that this function + * also works for Windows UNC root paths, e.g. \\hello\world + * @param p - file path + * @returns dirname of path + */ +export const getDirname = (p: string): string => { // Normalize slashes and trim unnecessary trailing slash p = safeTrimTrailingSeparator(p) // Windows UNC root, e.g. \\hello or \\hello\world - if (IS_WINDOWS && /^\\\\[^\\]+(\\[^\\]+)?$/.test(p)) { + if (isWindows() && /^\\\\[^\\]+(\\[^\\]+)?$/.test(p)) { return p } @@ -81,18 +99,31 @@ const dirname = (p: string): string => { let result = path.dirname(p) // Trim trailing slash for Windows UNC root, e.g. \\hello\world\ - if (IS_WINDOWS && /^\\\\[^\\]+\\[^\\]+\\$/.test(result)) { + if (isWindows() && /^\\\\[^\\]+\\[^\\]+\\$/.test(result)) { result = safeTrimTrailingSeparator(result) } return result } +/** + * Converts the version string to a number + * @param version - version string + * @returns version number + */ const versionToNumber = (version: string): number => { const [major, minor, patch] = version.split('.').map(Number) return major * 1000000 + minor * 1000 + patch } +/** + * Verifies the minimum required git version + * @returns minimum required git version + * @throws Minimum git version requirement is not met + * @throws Git is not installed + * @throws Git is not found in PATH + * @throws An unexpected error occurred + */ export const verifyMinimumGitVersion = async (): Promise => { const {exitCode, stdout, stderr} = await exec.getExecOutput( 'git', @@ -113,6 +144,11 @@ export const verifyMinimumGitVersion = async (): Promise => { } } +/** + * Checks if a path exists + * @param filePath - path to check + * @returns path exists + */ const exists = async (filePath: string): Promise => { try { await fs.access(filePath) @@ -122,6 +158,11 @@ const exists = async (filePath: string): Promise => { } } +/** + * Generates lines of a file as an async iterable iterator + * @param filePath - path of file to read + * @param excludedFiles - whether to exclude files + */ async function* lineOfFileGenerator({ filePath, excludedFiles @@ -153,6 +194,11 @@ async function* lineOfFileGenerator({ } } +/** + * Gets the file patterns from a source file + * @param filePaths - paths of files to read + * @param excludedFiles - whether to exclude the file patterns + */ const getFilesFromSourceFile = async ({ filePaths, excludedFiles = false @@ -169,6 +215,12 @@ const getFilesFromSourceFile = async ({ return lines } +/** + * Sets the global git configs + * @param name - name of config + * @param value - value of config + * @throws Couldn't update git global config + */ export const updateGitGlobalConfig = async ({ name, value @@ -191,6 +243,11 @@ export const updateGitGlobalConfig = async ({ } } +/** + * Checks if a git repository is shallow + * @param cwd - working directory + * @returns repository is shallow + */ export const isRepoShallow = async ({cwd}: {cwd: string}): Promise => { const {stdout} = await exec.getExecOutput( 'git', @@ -204,6 +261,11 @@ export const isRepoShallow = async ({cwd}: {cwd: string}): Promise => { return stdout.trim() === 'true' } +/** + * Checks if a submodule exists + * @param cwd - working directory + * @returns submodule exists + */ export const submoduleExists = async ({ cwd }: { @@ -227,6 +289,11 @@ export const submoduleExists = async ({ return stdout.trim() !== '' } +/** + * Fetches the git repository + * @param args - arguments for fetch command + * @param cwd - working directory + */ export const gitFetch = async ({ args, cwd @@ -243,6 +310,11 @@ export const gitFetch = async ({ return exitCode } +/** + * Fetches the git repository submodules + * @param args - arguments for fetch command + * @param cwd - working directory + */ export const gitFetchSubmodules = async ({ args, cwd @@ -266,10 +338,10 @@ export const gitFetchSubmodules = async ({ } } -const normalizePath = (p: string): string => { - return p.replace(/\\/g, '/') -} - +/** + * Retrieves all the submodule paths + * @param cwd - working directory + */ export const getSubmodulePath = async ({ cwd }: { @@ -296,6 +368,14 @@ export const getSubmodulePath = async ({ .map((line: string) => normalizePath(line.trim().split(' ')[1])) } +/** + * Retrieves commit sha of a submodule from a parent commit + * @param cwd - working directory + * @param parentSha1 - parent commit sha + * @param parentSha2 - parent commit sha + * @param submodulePath - path of submodule + * @param diff - diff type between parent commits (`..` or `...`) + */ export const gitSubmoduleDiffSHA = async ({ cwd, parentSha1, @@ -311,7 +391,7 @@ export const gitSubmoduleDiffSHA = async ({ }): Promise<{previousSha?: string; currentSha?: string}> => { const {stdout} = await exec.getExecOutput( 'git', - ['diff', parentSha1, parentSha2, '--', submodulePath], + ['diff', `${parentSha1}${diff}${parentSha2}`, '--', submodulePath], { cwd, silent: !core.isDebug() @@ -408,6 +488,16 @@ export const gitRenamedFiles = async ({ }) } +/** + * Retrieves all the changed files between two commits + * @param cwd - working directory + * @param sha1 - commit sha + * @param sha2 - commit sha + * @param diff - diff type between parent commits (`..` or `...`) + * @param isSubmodule - is the repo a submodule + * @param parentDir - parent directory of the submodule + * @param outputRenamedFilesAsDeletedAndAdded - output renamed files as deleted and added + */ export const getAllChangedFiles = async ({ cwd, sha1, @@ -494,6 +584,11 @@ export const getAllChangedFiles = async ({ return changedFiles } +/** + * Filters the changed files by the file patterns + * @param allDiffFiles - all the changed files + * @param filePatterns - file patterns to filter by + */ export const getFilteredChangedFiles = async ({ allDiffFiles, filePatterns @@ -518,7 +613,7 @@ export const getFilteredChangedFiles = async ({ if (hasFilePatterns) { changedFiles[changeType as ChangeTypeEnum] = mm(files, filePatterns, { dot: true, - windows: IS_WINDOWS, + windows: isWindows(), noext: true }) } else { @@ -710,15 +805,15 @@ export const canDiffCommits = async ({ } export const getDirnameMaxDepth = ({ - pathStr, + relativePath, dirNamesMaxDepth, excludeCurrentDir }: { - pathStr: string + relativePath: string dirNamesMaxDepth?: number excludeCurrentDir?: boolean }): string => { - const pathArr = dirname(pathStr).split(path.sep) + const pathArr = getDirname(relativePath).split(path.sep) const maxDepth = Math.min(dirNamesMaxDepth || pathArr.length, pathArr.length) let output = pathArr[0] @@ -815,7 +910,7 @@ export const getFilePatterns = async ({ filePatterns = filePatterns.concat('\n', filesIgnoreFromSourceFiles) } - if (IS_WINDOWS) { + if (isWindows()) { filePatterns = filePatterns.replace(/\r\n/g, '\n') filePatterns = filePatterns.replace(/\r/g, '\n') } @@ -1129,7 +1224,7 @@ export const recoverDeletedFiles = async ({ if (recoverPatterns.length > 0) { recoverableDeletedFiles = mm(deletedFiles, recoverPatterns, { dot: true, - windows: IS_WINDOWS, + windows: isWindows(), noext: true }) core.debug(`filtered recoverable deleted files: ${recoverableDeletedFiles}`)