Calculate a partial fence difference based on git changes since a provided oid

.vscode/launch.json

@@ -0,0 +1,30 @@
+{
+    // Use IntelliSense to learn about possible attributes.
+    // Hover to view descriptions of existing attributes.
+    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "name": "SingleTest",
+            "type": "node",
+            "request": "launch",
+            "program": "${workspaceRoot}/node_modules/jest-cli/bin/jest.js",
+            "args": ["--testPathPattern", "${fileBasenameNoExtension}"],
+            "cwd": "${workspaceRoot}",
+            "preLaunchTask": null,
+            "runtimeExecutable": null,
+            "runtimeArgs": ["--nolazy"],
+            "env": {
+                "NODE_ENV": "development"
+            },
+            "sourceMaps": true,
+            "outFiles": ["${workspaceRoot}/src/**"],
+            "console": "integratedTerminal",
+            "skipFiles": [
+                "<node_internals>/**/*.js",
+                "${workspaceRoot}/node_modules/jest-*/**",
+                "${workspaceRoot}/node_modules/jsdom/**"
+            ]
+        }
+    ]
+}

jest.config.js

@@ -1,7 +1,14 @@
 module.exports = {
     testEnvironment: 'node',
     moduleDirectories: ['node_modules'],
-    moduleFileExtensions: ['ts', 'js'],
+    moduleFileExtensions: [
+        'ts',
+        'js',
+        // nodegit parses its own package.json file,
+        // so we need this moduleFileExtension to be
+        // specified for tests.
+        'json',
+    ],
     transform: {
         '.ts': '<rootDir>/jest.preprocessor.js',
     },

package.json

@@ -19,6 +19,7 @@
         "commander": "^7.2.0",
         "fdir": "^5.1.0",
         "minimatch": "^3.0.4",
+        "nodegit": "^0.27.0",
         "picomatch": "^2.3.0",
         "tsconfig-paths": "^3.10.1",
         "typescript": "^4.0.3"
@@ -28,6 +29,7 @@
         "@types/commander": "^2.12.2",
         "@types/jest": "^26.0.15",
         "@types/node": "^12.7.8",
+        "@types/nodegit": "^0.27.2",
         "husky": "^4.3.8",
         "jest": "^26.6.0",
         "prettier": "^2.2.1",

src/core/cli.ts

@@ -11,6 +11,14 @@ async function main() {
         .version(packageVersion)
         .option('-p, --project <string> ', 'tsconfig.json file')
         .option('-r, --rootDir <string...>', 'root directories of the project')
+        .option(
+            '-g, --sinceGitHash <string>',
+            'Infer files and fences to check based on changes since the specified git hash'
+        )
+        .option(
+            '-l, --partialCheckLimit <number>',
+            'Maximum files to check during a partial check run. If more files than this limit are changed, the partial check will be aborted and good-fences will exit with code 0.'
+        )
         .option(
             '-x, --looseRootFileDiscovery',
             '(UNSTABLE) Check source files under rootDirs instead of instantiating a full typescript program.'

src/core/result.ts

@@ -54,9 +54,9 @@ export function reportConfigError(message: string, configPath: string) {
 
 export function reportWarning(message: string, configPath?: string) {
     let fencePath = configPath + path.sep + 'fence.json';
-    let detailedMessage = `Good-fences warning: ${message}\n`;
+    let detailedMessage = `Good-fences warning: ${message}`;
     if (configPath) {
-        detailedMessage += `    Fence: ${fencePath}`;
+        detailedMessage += `\n    Fence: ${fencePath}`;
     }
 
     const warning: GoodFencesError = {

src/core/runner.ts

@@ -3,12 +3,27 @@ import getOptions, { setOptions } from '../utils/getOptions';
 import validateFile from '../validation/validateFile';
 import TypeScriptProgram from './TypeScriptProgram';
 import normalizePath from '../utils/normalizePath';
-import { getResult } from './result';
+import { getResult, reportWarning } from './result';
 import { validateTagsExist } from '../validation/validateTagsExist';
 import { SourceFileProvider } from './SourceFileProvider';
 import { FDirSourceFileProvider } from './FdirSourceFileProvider';
 import NormalizedPath from '../types/NormalizedPath';
 import { runWithConcurrentLimit } from '../utils/runWithConcurrentLimit';
+import getConfigManager from '../utils/getConfigManager';
+import { getFenceAndImportDiffsFromGit } from '../utils/getFenceAndImportDiffsFromGit';
+import { getPartialCheckFromImportDiffs } from '../utils/getPartialCheckFromImportDiffs';
+import * as path from 'path';
+import { PartialCheck } from '../types/PartialCheck';
+
+async function getPartialCheck(): Promise<PartialCheck> {
+    let options = getOptions();
+    if (options.sinceGitHash) {
+        const diffs = await getFenceAndImportDiffsFromGit(options.sinceGitHash);
+        if (diffs) {
+            return getPartialCheckFromImportDiffs(diffs);
+        }
+    }
+}
 
 async function getSourceFilesNormalized(
     sourceFileProvider: SourceFileProvider,
@@ -24,24 +39,75 @@ export async function run(rawOptions: RawOptions) {
     setOptions(rawOptions);
     let options = getOptions();
 
+    let partialCheck = await getPartialCheck();
+    if (options.partialCheckLimit) {
+        if (!partialCheck) {
+            reportWarning(
+                `Skipping fence validation. Could not calculate a partial check, but partialCheckLimit was specified in options`
+            );
+            return getResult();
+        }
+        if (
+            partialCheck.fences.length + partialCheck.sourceFiles.length >
+            options.partialCheckLimit
+        ) {
+            reportWarning(
+                `Skipping fence validation. The partial check had more than ${options.partialCheckLimit} changes`
+            );
+            return getResult();
+        }
+    }
+
     let sourceFileProvider: SourceFileProvider = options.looseRootFileDiscovery
         ? new FDirSourceFileProvider(options.project, options.rootDir)
         : new TypeScriptProgram(options.project);
 
-    // Do some sanity checks on the fences
-    validateTagsExist();
+    if (!partialCheck) {
+        // validating tags exist requires a full load of all fences
+        // we can't do this in partial check mode.
+        //
+        // Prefetching the full config set here avoids the overhead
+        // of partial fence loading, since we know we are loading
+        // the full fence set.
+        getConfigManager().getAllConfigs();
+        validateTagsExist();
+    } else {
+        reportWarning(
+            `skipping validateTagsExist. Cannot validate tag existence during partial checks`
+        );
+    }
+
+    if (partialCheck) {
+        // validate only those files specified on the command line,
+        // or included in the scope of changed fence files.
+        const fenceScopeFiles = await getSourceFilesNormalized(
+            sourceFileProvider,
+            partialCheck.fences.map((fencePath: NormalizedPath) => path.dirname(fencePath))
+        );
 
-    const normalizedFiles = await getSourceFilesNormalized(sourceFileProvider);
+        const normalizedFiles = [...partialCheck.sourceFiles, ...fenceScopeFiles];
 
-    // Limit the concurrent executed promises because
-    // otherwise we will open all the files at the same time and
-    // hit the MFILE error (when we hit rlimit)
-    await runWithConcurrentLimit(
-        options.maxConcurrentFenceJobs,
-        normalizedFiles,
-        (normalizedFile: NormalizedPath) => validateFile(normalizedFile, sourceFileProvider),
-        options.progress
-    );
+        // we have to limit the concurrent executed promises because
+        // otherwise we will open all the files at the same time and
+        // hit the MFILE error (when we hit rlimit)
+        await runWithConcurrentLimit(
+            options.maxConcurrentFenceJobs,
+            normalizedFiles,
+            (normalizedFile: NormalizedPath) => validateFile(normalizedFile, sourceFileProvider),
+            options.progress
+        );
+    } else {
+        const normalizedFiles = await getSourceFilesNormalized(sourceFileProvider);
 
+        // we have to limit the concurrent executed promises because
+        // otherwise we will open all the files at the same time and
+        // hit the MFILE error (when we hit rlimit)
+        await runWithConcurrentLimit(
+            options.maxConcurrentFenceJobs,
+            normalizedFiles,
+            (normalizedFile: NormalizedPath) => validateFile(normalizedFile, sourceFileProvider),
+            options.progress
+        );
+    }
     return getResult();
 }

src/types/Options.ts

@@ -4,6 +4,8 @@ export default interface Options {
     project: NormalizedPath;
     rootDir: NormalizedPath[];
     ignoreExternalFences: boolean;
+    partialCheckLimit: number;
+    sinceGitHash?: string;
     looseRootFileDiscovery: boolean;
     // Maximum number of fence validation jobs that can
     // be run at the same time.

src/types/PartialCheck.ts

@@ -0,0 +1,6 @@
+import NormalizedPath from './NormalizedPath';
+
+export type PartialCheck = {
+    fences: NormalizedPath[];
+    sourceFiles: NormalizedPath[];
+};

src/types/RawOptions.ts

@@ -2,6 +2,8 @@ export default interface RawOptions {
     project?: string;
     rootDir?: string | string[];
     ignoreExternalFences?: boolean;
+    sinceGitHash?: string;
+    partialCheckLimit?: number;
     looseRootFileDiscovery?: boolean;
     maxConcurrentJobs?: number;
     progressBar?: boolean;

src/types/config/Config.ts

@@ -4,8 +4,8 @@ import ExportRule from './ExportRule';
 
 export default interface Config {
     path: NormalizedPath;
-    tags: string[];
-    exports: ExportRule[];
-    dependencies: DependencyRule[];
-    imports: string[];
+    tags: string[] | null;
+    exports: ExportRule[] | null;
+    dependencies: DependencyRule[] | null;
+    imports: string[] | null;
 }