@boll/core - npm Package Compare versions

Comparing version 1.6.0 to 2.0.0

CHANGELOG.json

@@ -5,3 +5,18 @@ {
     {
-      "date": "Tue, 15 Dec 2020 17:21:35 GMT",
+      "date": "Tue, 16 Feb 2021 20:17:21 GMT",
+      "tag": "@boll/core_v2.0.0",
+      "version": "2.0.0",
+      "comments": {
+        "major": [
+          {
+            "comment": "Unused dep detector",
+            "author": "email not defined",
+            "commit": "f63555b024b0e7f44d359805bc1af296f68b19f9",
+            "package": "@boll/core"
+          }
+        ]
+      }
+    },
+    {
+      "date": "Tue, 15 Dec 2020 17:22:23 GMT",
       "tag": "@boll/core_v1.6.0",
@@ -8,0 +23,0 @@ "version": "1.6.0",

CHANGELOG.md

 # Change Log - @boll/core
 
-This log was last generated on Tue, 15 Dec 2020 17:21:35 GMT and should not be manually modified.
+This log was last generated on Tue, 16 Feb 2021 20:17:21 GMT and should not be manually modified.
 
 <!-- Start content -->
 
+## 2.0.0
+
+Tue, 16 Feb 2021 20:17:21 GMT
+
+### Major changes
+
+- Unused dep detector (email not defined)
+
 ## 1.6.0
 
-Tue, 15 Dec 2020 17:21:35 GMT
+Tue, 15 Dec 2020 17:22:23 GMT
 
@@ -11,0 +19,0 @@ ### Minor changes

dist/config.js

@@ -115,3 +115,3 @@ "use strict";
                                 glob.include = ruleSetConfig.include || [];
-                                var checks = (ruleSetConfig.checks || []).map(function (check) {
+                                var fileChecks = ((ruleSetConfig.checks && ruleSetConfig.checks.file) || []).map(function (check) {
                                     var optionsFromConfig = (config.configuration && config.configuration.rules && config.configuration.rules[check.rule]) || {};
@@ -122,3 +122,9 @@ var options = __assign(__assign({}, check.options), optionsFromConfig);
                                 });
-                                return new rule_set_1.RuleSet(glob, checks);
+                                var metaChecks = ((ruleSetConfig.checks && ruleSetConfig.checks.meta) || []).map(function (check) {
+                                    var optionsFromConfig = (config.configuration && config.configuration.rules && config.configuration.rules[check.rule]) || {};
+                                    var options = __assign(__assign({}, check.options), optionsFromConfig);
+                                    var rule = _this.ruleRegistry.get(check.rule)(_this.logger, options);
+                                    return new rule_set_1.InstantiatedPackageMetaRule(rule.name, check.severity || "error", rule);
+                                });
+                                return new rule_set_1.RuleSet(glob, fileChecks, metaChecks);
                             })];
@@ -125,0 +131,0 @@ }

dist/file-context.d.ts

@@ -5,3 +5,3 @@ import ts from "typescript";
 import { DependencyMap, Package } from "./package";
-import { PackageRule } from "./types";
+import { Rule } from "./types";
 export declare class FileContext {
@@ -25,4 +25,4 @@ packageRoot: BollDirectory;
     get relativeFilename(): string;
-    shouldSkip(r: PackageRule): boolean;
+    shouldSkip(r: Rule): boolean;
 }
 export declare function getSourceFile(projectRoot: BollDirectory, filename: string, packageContext: Package): Promise<FileContext>;

dist/package.d.ts

@@ -0,1 +1,2 @@
+import { BollFile } from "./boll-file";
 export declare type DependencyMap = {
@@ -8,2 +9,3 @@ [depdencyName: string]: string;
     constructor(dependencies: DependencyMap, devDependencies: DependencyMap);
+    static parse(file: BollFile): Package;
 }

dist/package.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Package = void 0;
+var fs_1 = require("fs");
 var Package = /** @class */ (function () {
@@ -9,4 +10,14 @@ function Package(dependencies, devDependencies) {
     }
+    Package.parse = function (file) {
+        try {
+            var fileContents = fs_1.readFileSync(file).toString();
+            var json = JSON.parse(fileContents);
+            return new Package(json["dependencies"] || {}, json["devDependencies"] || {});
+        }
+        catch (e) {
+            return new Package({}, {});
+        }
+    };
     return Package;
 }());
 exports.Package = Package;

dist/rule-registry.d.ts

 import { Logger } from "./logger";
-import { PackageRule } from "./types";
-export declare type RuleDefinition = (logger: Logger, options?: {}) => PackageRule;
+import { Rule } from "./types";
+export declare type RuleDefinition<T extends Rule> = (logger: Logger, options?: {}) => T;
 export declare class RuleRegistry {
     registrations: {
-        [name: string]: RuleDefinition;
+        [name: string]: RuleDefinition<Rule>;
     };
-    register(name: string, factory: RuleDefinition): void;
-    get(name: string): RuleDefinition;
+    register<T extends Rule>(name: string, factory: RuleDefinition<T>): void;
+    get<T extends Rule>(name: string): RuleDefinition<T>;
 }
 export declare const RuleRegistryInstance: RuleRegistry;

dist/rule-set.d.ts

 import { FileContext } from "./file-context";
 import { Result } from "./result-set";
-import { CheckSeverity, FileGlob, PackageRule } from "./types";
-export declare class InstantiatedPackageRule {
+import { CheckSeverity, FileGlob, PackageMetaRule, PackageRule } from "./types";
+export interface InstantiatedRule {
     name: string;
     severity: CheckSeverity;
+}
+export declare class InstantiatedPackageRule implements InstantiatedRule {
+    name: string;
+    severity: CheckSeverity;
     rule: PackageRule;
@@ -11,6 +15,14 @@ constructor(name: string, severity: CheckSeverity, rule: PackageRule);
 }
+export declare class InstantiatedPackageMetaRule implements InstantiatedRule {
+    name: string;
+    severity: CheckSeverity;
+    rule: PackageMetaRule;
+    constructor(name: string, severity: CheckSeverity, rule: PackageMetaRule);
+    check(files: FileContext[]): Promise<Result[]>;
+}
 export declare class RuleSet {
     fileGlob: FileGlob;
-    checks: InstantiatedPackageRule[];
-    constructor(fileGlob: FileGlob, checks: InstantiatedPackageRule[]);
+    fileChecks: InstantiatedPackageRule[];
+    metaChecks: InstantiatedPackageMetaRule[];
+    constructor(fileGlob: FileGlob, fileChecks: InstantiatedPackageRule[], metaChecks: InstantiatedPackageMetaRule[]);
 }

dist/rule-set.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RuleSet = exports.InstantiatedPackageRule = void 0;
+exports.RuleSet = exports.InstantiatedPackageMetaRule = exports.InstantiatedPackageRule = void 0;
 var InstantiatedPackageRule = /** @class */ (function () {
@@ -16,6 +16,19 @@ function InstantiatedPackageRule(name, severity, rule) {
 exports.InstantiatedPackageRule = InstantiatedPackageRule;
+var InstantiatedPackageMetaRule = /** @class */ (function () {
+    function InstantiatedPackageMetaRule(name, severity, rule) {
+        this.name = name;
+        this.severity = severity;
+        this.rule = rule;
+    }
+    InstantiatedPackageMetaRule.prototype.check = function (files) {
+        return this.rule.check(files);
+    };
+    return InstantiatedPackageMetaRule;
+}());
+exports.InstantiatedPackageMetaRule = InstantiatedPackageMetaRule;
 var RuleSet = /** @class */ (function () {
-    function RuleSet(fileGlob, checks) {
+    function RuleSet(fileGlob, fileChecks, metaChecks) {
         this.fileGlob = fileGlob;
-        this.checks = checks;
+        this.fileChecks = fileChecks;
+        this.metaChecks = metaChecks;
     }
@@ -22,0 +35,0 @@ return RuleSet;

dist/suite.d.ts

@@ -13,2 +13,3 @@ import { FileContext } from "./file-context";
     filterIgnoredChecksByLine(results: Result[], sourceFile: FileContext): Promise<Result[]>;
+    private addFailuresWithSeverity;
 }

dist/suite.js

@@ -104,3 +104,3 @@ "use strict";
                         sourceFiles = _a.sent();
-                        ruleSet.checks.forEach(function (r) {
+                        ruleSet.fileChecks.forEach(function (r) {
                             sourceFiles.forEach(function (s) { return __awaiter(_this, void 0, void 0, function () {
@@ -119,11 +119,3 @@ var results, filteredResults;
                                             filteredResults = _a.sent();
-                                            if (r.severity === "error") {
-                                                resultSet.addErrors(filteredResults);
-                                            }
-                                            else if (r.severity === "warn") {
-                                                resultSet.addWarnings(filteredResults);
-                                            }
-                                            else {
-                                                throw new Error("Unknown severity! (This is likely a boll bug)");
-                                            }
+                                            this.addFailuresWithSeverity(r, filteredResults, resultSet);
                                             return [2 /*return*/];
@@ -134,2 +126,16 @@ }
                         });
+                        ruleSet.metaChecks.forEach(function (r) { return __awaiter(_this, void 0, void 0, function () {
+                            var unskippedSourceFiles, results;
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0:
+                                        unskippedSourceFiles = sourceFiles.filter(function (s) { return !s.shouldSkip(r); });
+                                        return [4 /*yield*/, r.check(unskippedSourceFiles)];
+                                    case 1:
+                                        results = _a.sent();
+                                        this.addFailuresWithSeverity(r, results, resultSet);
+                                        return [2 /*return*/];
+                                }
+                            });
+                        }); });
                         return [2 /*return*/, true];
@@ -185,4 +191,15 @@ }
     };
+    Suite.prototype.addFailuresWithSeverity = function (rule, results, resultSet) {
+        if (rule.severity === "error") {
+            resultSet.addErrors(results);
+        }
+        else if (rule.severity === "warn") {
+            resultSet.addWarnings(results);
+        }
+        else {
+            throw new Error("Unknown severity! (This is likely a boll bug)");
+        }
+    };
     return Suite;
 }());
 exports.Suite = Suite;

dist/tests/config.test.js

@@ -102,3 +102,6 @@ "use strict";
     });
-    configRegistry.register({ name: "base", ruleSets: [{ fileLocator: new FakeGlob(), checks: [{ rule: "foo" }] }] });
+    configRegistry.register({
+        name: "base",
+        ruleSets: [{ fileLocator: new FakeGlob(), checks: { file: [{ rule: "foo" }] } }]
+    });
     configRegistry.register({ name: "level1", extends: "base" });
@@ -141,3 +144,5 @@ configRegistry.register({ name: "level2", extends: "level1" });
     var config = new config_1.Config(configRegistry, ruleRegistry, logger_1.NullLogger);
-    config.load({ ruleSets: [{ fileLocator: new FakeGlob(), checks: [{ rule: "foo", options: { bar: "baz" } }] }] });
+    config.load({
+        ruleSets: [{ fileLocator: new FakeGlob(), checks: { file: [{ rule: "foo", options: { bar: "baz" } }] } }]
+    });
     config.buildSuite();
@@ -154,3 +159,3 @@ assert.ok(calledWithCorrectArgs, "Rule factory should have been invoked with correct args when creating suite.");
                     name: "base",
-                    ruleSets: [{ fileLocator: new FakeGlob(), checks: [{ rule: "foo", options: { bar: "baz" } }] }]
+                    ruleSets: [{ fileLocator: new FakeGlob(), checks: { file: [{ rule: "foo", options: { bar: "baz" } }] } }]
                 });
@@ -174,3 +179,3 @@ ruleRegistry = new rule_registry_1.RuleRegistry();
                 suite = _a.sent();
-                fakeRuleInstance = suite.ruleSets[0].checks[0].rule;
+                fakeRuleInstance = suite.ruleSets[0].fileChecks[0].rule;
                 assert.deepStrictEqual(fakeRuleInstance.options, { bar: "baz", some: "rule" });
@@ -177,0 +182,0 @@ return [2 /*return*/];

dist/tests/result.test.js

@@ -107,3 +107,5 @@ "use strict";
                                 myConfig = {
-                                    ruleSets: [{ fileLocator: new glob_1.TypescriptSourceGlob(), checks: [{ rule: "foo", options: { bar: "baz" } }] }],
+                                    ruleSets: [
+                                        { fileLocator: new glob_1.TypescriptSourceGlob(), checks: { file: [{ rule: "foo", options: { bar: "baz" } }] } }
+                                    ],
                                     configuration: {
@@ -151,3 +153,3 @@ rules: {
                                             fileLocator: new glob_1.TypescriptSourceGlob(),
-                                            checks: [{ severity: "warn", rule: "foo", options: { bar: "baz" } }]
+                                            checks: { file: [{ severity: "warn", rule: "foo", options: { bar: "baz" } }] }
                                         }
@@ -154,0 +156,0 @@ ],

dist/types.d.ts

@@ -9,5 +9,9 @@ import { BollFile } from "./boll-file";
 }
+export interface Checks {
+    file?: CheckConfiguration[];
+    meta?: CheckConfiguration[];
+}
 export interface RuleSetConfiguration {
     fileLocator: FileGlob;
-    checks?: CheckConfiguration[];
+    checks?: Checks;
     exclude?: string[];
@@ -28,6 +32,11 @@ include?: string[];
 }
-export interface PackageRule {
+export interface Rule {
     name: string;
+}
+export interface PackageRule extends Rule {
     check(file: FileContext): Promise<Result[]>;
 }
+export interface PackageMetaRule extends Rule {
+    check(files: FileContext[]): Promise<Result[]>;
+}
 export declare enum ResultStatus {
@@ -34,0 +43,0 @@ success = 0,

package.json

@@ -48,3 +48,3 @@ {
   },
-  "version": "1.6.0"
+  "version": "2.0.0"
 }

No alert changes

Improved metrics

Total package byte prevSize

195974

increased by2.07%

Lines of code

4213

increased by2.26%

Worsened metrics

Number of low supply chain risk alerts

3

increased by50%

No dependency changes