@W-14980290@: Implement Pmd7CommandInfo to allow us to call pmd7 jars

src/Constants.ts

@@ -2,6 +2,7 @@ import os = require('os');
 import path = require('path');
 
 export const PMD6_VERSION = '6.55.0';
+export const PMD7_VERSION = '7.0.0-rc4';
 export const PMD_APPEXCHANGE_RULES_VERSION = '0.12';
 export const SFGE_VERSION = '1.0.1-pilot';
 export const DEFAULT_SCANNER_PATH = path.join(os.homedir(), '.sfdx-scanner');
@@ -133,6 +134,7 @@ export enum Severity {
 
 // Here, current dir __dirname = <base_dir>/sfdx-scanner/src
 export const PMD6_LIB = path.join(__dirname, '..', 'dist', 'pmd', 'lib');
+export const PMD7_LIB = path.join(__dirname, '..', 'dist', 'pmd7', 'lib');
 
 // Here, current dir __dirname = <base_dir>/sfdx-scanner/src
 export const APPEXCHANGE_PMD_LIB = path.join(__dirname, '..', 'pmd-appexchange', 'lib');

src/lib/Display.ts

@@ -1,5 +1,6 @@
 import {Spinner} from "@salesforce/sf-plugins-core";
 import {Ux} from "@salesforce/sf-plugins-core/lib/ux";
+import {AnyJson} from "@salesforce/ts-types";
 
 export interface Display {
 	/**
@@ -27,6 +28,11 @@ export interface Display {
 	 */
 	displayTable<R extends Ux.Table.Data>(data: R[], columns: Ux.Table.Columns<R>): void;
 
+	/**
+	 * Output object to stdout only if the "--json" flag is not present.
+	 */
+	displayStyledObject(obj: AnyJson): void;
+
 	/**
 	 * Display a message as a warning.
 	 */
@@ -91,6 +97,10 @@ export class UxDisplay implements Display {
 		this.displayable.table(data, columns);
 	}
 
+	public displayStyledObject(obj: AnyJson): void {
+		this.displayable.styledObject(obj);
+	}
+
 	public displayWarning(msg: string): void {
 		this.displayable.warn(msg);
 	}
@@ -126,13 +136,15 @@ export interface Displayable {
 	// Display an error or message as a warning.                                            [Implemented by Command]
 	warn(input: string): void;
 
-
 	// Simplified prompt for single-question confirmation. Times out and throws after 10s.  [Implemented by SfCommand]
 	confirm(message: string): Promise<boolean>;
 
 	// Output stylized header to stdout only when "--json" flag is not present.             [Implemented by SfCommand]
 	styledHeader(headerText: string): void;
 
+	// Output stylized object to stdout only when "--json" flag is not present.             [Implemented by SfCommand]
+	styledObject(obj: AnyJson): void;
+
 	// Output table to stdout only when "--json" flag is not present.                       [Implemented by SfCommand]
 	table<R extends Ux.Table.Data>(data: R[], columns: Ux.Table.Columns<R>, options?: Ux.Table.Options): void;
 }

src/lib/actions/RuleDescribeAction.ts

@@ -7,7 +7,6 @@ import {BundleName, getMessage} from "../../MessageCatalog";
 import {deepCopy} from "../util/Utils";
 import Dfa from "../../commands/scanner/run/dfa";
 import Run from "../../commands/scanner/run";
-import {Ux} from "@salesforce/sf-plugins-core";
 import {Display} from "../Display";
 import {RuleFilterFactory} from "../RuleFilterFactory";
 
@@ -34,8 +33,6 @@ export class RuleDescribeAction implements Action {
 	}
 
 	public async run(inputs: Inputs): Promise<AnyJson> {
-		const jsonEnabled: boolean = inputs.json as boolean;
-
 		const ruleFilters: RuleFilter[] = this.ruleFilterFactory.createRuleFilters(inputs);
 
 		// TODO: Inject RuleManager as a dependency to improve testability by removing coupling to runtime implementation
@@ -52,11 +49,11 @@ export class RuleDescribeAction implements Action {
 			this.display.displayWarning(msg);
 			rules.forEach((rule, idx) => {
 				this.display.displayStyledHeader(`Rule #${idx + 1}`);
-				this.displayStyledRule(rule, jsonEnabled);
+				this.displayStyledRule(rule);
 			});
 		} else {
 			// If there's exactly one rule, we don't need to do anything special, and can just log the rule.
-			this.displayStyledRule(rules[0], jsonEnabled);
+			this.displayStyledRule(rules[0]);
 		}
 		// We need to return something for when the --json flag is used, so we'll just return the list of rules.
 		return deepCopy(rules);
@@ -87,9 +84,18 @@ export class RuleDescribeAction implements Action {
 		});
 	}
 
-	private displayStyledRule(rule: DescribeStyledRule, jsonEnabled: boolean): void {
-		// TODO: We should remove this instantiation of new Ux in favor of possibly a new method on Display
-		new Ux({jsonEnabled: jsonEnabled})
-			.styledObject(rule, ['name', 'engine', 'runWith', 'isPilot', 'enabled', 'categories', 'rulesets', 'languages', 'description', 'message']);
+	private displayStyledRule(rule: DescribeStyledRule): void {
+		this.display.displayStyledObject({
+			name: rule.name,
+			engine: rule.engine,
+			runWith: rule.runWith,
+			isPilot: rule.isPilot,
+			enabled: rule.enabled,
+			categories: rule.categories,
+			rulesets: rule.rulesets,
+			languages: rule.languages,
+			description: rule.description,
+			message: rule.message
+		})
 	}
 }

src/lib/cpd/CpdEngine.ts

@@ -216,10 +216,10 @@ export class CpdEngine extends AbstractRuleEngine {
 			for (const occ of occurences) {
 				// create a violation for each occurence of the code fragment
 				const violation: RuleViolation = {
-					line: occ.attributes.line as number,
-					column: occ.attributes.column as number,
-					endLine: occ.attributes.endline as number,
-					endColumn: occ.attributes.endcolumn as number,
+					line: Number(occ.attributes.line),
+					column: Number(occ.attributes.column),
+					endLine: Number(occ.attributes.endline),
+					endColumn: Number(occ.attributes.endcolumn),
 					ruleName: CpdRuleName,
 					severity: CpdViolationSeverity,
 					message: getMessage(BundleName.CpdEngine, "CpdViolationMessage", [codeFragmentID, occCount, occurences.length, duplication.attributes.lines, duplication.attributes.tokens]),

src/lib/pmd/PmdCommandInfo.ts

@@ -1,8 +1,9 @@
-import {PMD6_LIB, PMD6_VERSION} from "../../Constants";
+import {PMD6_LIB, PMD6_VERSION, PMD7_LIB, PMD7_VERSION} from "../../Constants";
 import * as path from 'path';
 
 const PMD6_MAIN_CLASS = 'net.sourceforge.pmd.PMD';
 const CPD6_MAIN_CLASS = 'net.sourceforge.pmd.cpd.CPD';
+const PMD7_CLI_CLASS = 'net.sourceforge.pmd.cli.PmdCli';
 const HEAP_SIZE = '-Xmx1024m';
 
 export interface PmdCommandInfo {
@@ -40,6 +41,33 @@ export class Pmd6CommandInfo implements PmdCommandInfo {
 	constructJavaCommandArgsForCpd(fileList: string, minimumTokens: number, language: string): string[] {
 		const classpath = `${PMD6_LIB}/*`;
 		return ['-cp', classpath, HEAP_SIZE, CPD6_MAIN_CLASS, '--filelist', fileList,
-			'--format', 'xml', '--minimum-tokens', String(minimumTokens), '--language', language];
+			'--format', 'xml', '--minimum-tokens', minimumTokens.toString(), '--language', language];
+	}
+}
+
+export class Pmd7CommandInfo implements PmdCommandInfo {
+	getVersion(): string {
+		return PMD7_VERSION;
+	}
+
+	getJarPathForLanguage(language: string): string {
+		return path.join(PMD7_LIB, `pmd-${language}-${this.getVersion()}.jar`);
+	}
+
+	constructJavaCommandArgsForPmd(fileList: string, classPathsForExternalRules: string[], rulesets: string): string[] {
+		const classpath =  classPathsForExternalRules.concat([`${PMD7_LIB}/*`]).join(path.delimiter);
+		const args = ['-cp', classpath, HEAP_SIZE, PMD7_CLI_CLASS, 'check', '--file-list', fileList,
+			'--format', 'xml'];
+		if (rulesets.length > 0) {
+			args.push('--rulesets', rulesets);
+		}
+		return args;
+	}
+
+	constructJavaCommandArgsForCpd(fileList: string, minimumTokens: number, language: string): string[] {
+		const classpath = `${PMD7_LIB}/*`;
+		const resolvedLanguage = language === 'visualforce' ? 'vf' : language;
+		return ['-cp', classpath, HEAP_SIZE, PMD7_CLI_CLASS, 'cpd', '--file-list', fileList, '--format', 'xml',
+			'--minimum-tokens', minimumTokens.toString(), '--language', resolvedLanguage, '--skip-lexical-errors'];
 	}
 }

src/types.d.ts

@@ -18,6 +18,7 @@ export type Rule = {
 	// be OR'd together in this property.
 	defaultConfig?: ESRuleConfigValue;
 	url?: string;
+	message?: string;
 }
 
 export type TelemetryData = {

test/commands/scanner/rule/describe.test.ts

@@ -60,7 +60,7 @@ describe('scanner rule describe', () => {
 				expect(ctx.stderr.toLowerCase()).to.contain(`WARNING: ${formattedWarning}`.toLowerCase(), 'Warning message should be formatted correctly');
 
 				// Next, verify that there are rule descriptions that are distinctly identified.
-				const regex = /=== Rule #1\n\nname:\s+constructor-super(.*\n)*=== Rule #2\n\nname:\s+constructor-super(.*\n)*=== Rule #3\n\nname:\s+constructor-super/g;
+				const regex = /=== Rule #1\n(.*\n)*name:\s+constructor-super(.*\n)*=== Rule #2\n(.*\n)*name:\s+constructor-super(.*\n)*=== Rule #3\n(.*\n)*name:\s+constructor-super/g;
 				expect(ctx.stdout).to.match(regex, 'Output should contain three rules named constructor-super for each eslint based engine');
 			});
 

test/lib/FakeDisplay.ts

@@ -1,11 +1,13 @@
 import {Display} from "../../src/lib/Display";
 import {Ux} from "@salesforce/sf-plugins-core";
+import {AnyJson} from "@salesforce/ts-types";
 
 export class FakeDisplay implements Display {
 	private outputs: string[] = [];
 	private confirmationPromptResponse: boolean = true;
 	private lastTableColumns: Ux.Table.Columns<Ux.Table.Data>;
 	private lastTableData: Ux.Table.Data[];
+	private lastStyledObject: AnyJson;
 
 	public getOutputArray(): string[] {
 		return this.outputs;
@@ -27,6 +29,10 @@ export class FakeDisplay implements Display {
 		return this.lastTableData;
 	}
 
+	public getLastStyledObject(): AnyJson {
+		return this.lastStyledObject;
+	}
+
 
 	displayConfirmationPrompt(msg: string): Promise<boolean> {
 		this.outputs.push(msg);
@@ -59,6 +65,11 @@ export class FakeDisplay implements Display {
 		this.outputs.push("[Table][" + JSON.stringify(columns) + "]: " + JSON.stringify(data));
 	}
 
+	displayStyledObject(obj: AnyJson): void {
+		this.lastStyledObject = obj;
+		this.outputs.push(JSON.stringify(obj))
+	}
+
 	spinnerStart(msg: string, status?: string): void {
 		const statusText = status ? "[" + status + "]" : "";
 		this.outputs.push("[SpinnerStart]" + statusText + ": " + msg)

test/lib/actions/RuleDescribeAction.test.ts

@@ -0,0 +1,69 @@
+import {FakeDisplay} from "../FakeDisplay";
+import {initContainer} from "../../../src/ioc.config";
+import {RuleFilterFactoryImpl} from "../../../src/lib/RuleFilterFactory";
+import {Pmd7CommandInfo, PmdCommandInfo} from "../../../src/lib/pmd/PmdCommandInfo";
+import {Controller} from "../../../src/Controller";
+import {after} from "mocha";
+import {Inputs} from "../../../src/types";
+import {expect} from "chai";
+import {RuleDescribeAction} from "../../../src/lib/actions/RuleDescribeAction";
+import {AnyJson} from "@salesforce/ts-types";
+
+describe("Tests for RuleDescribeAction", () => {
+	let display: FakeDisplay;
+	let ruleDescribeAction: RuleDescribeAction;
+	before(() => {
+		initContainer();
+	});
+	beforeEach(() => {
+		display = new FakeDisplay();
+		ruleDescribeAction = new RuleDescribeAction(display, new RuleFilterFactoryImpl());
+	});
+
+	describe("Tests to confirm that PMD7 binary files are invoked when choosing PMD7 with pmd engine", () => {
+
+		// TODO: Soon we will have an input flag to control this. Once we do, we can update this to use that instead
+		const originalPmdCommandInfo: PmdCommandInfo = Controller.getActivePmdCommandInfo()
+		before(() => {
+			Controller.setActivePmdCommandInfo(new Pmd7CommandInfo());
+		});
+		after(() => {
+			Controller.setActivePmdCommandInfo(originalPmdCommandInfo);
+		});
+
+		it("When using PMD7, the rule description for a pmd rule should give correct info from PMD 7", async () => {
+			const inputs: Inputs = {
+				rulename: 'ApexCRUDViolation'
+			}
+			await ruleDescribeAction.run(inputs);
+
+			const rule: AnyJson  = display.getLastStyledObject();
+			expect(rule['name']).to.equal('ApexCRUDViolation');
+			expect(rule['engine']).to.equal('pmd');
+			expect(rule['isPilot']).to.equal(false);
+			expect(rule['enabled']).to.equal(true);
+			expect(rule['categories']).to.deep.equal(['Security']);
+			expect(rule['rulesets']).to.contain('quickstart');
+			expect(rule['languages']).to.deep.equal(['apex']);
+			expect(rule['description']).to.have.length.greaterThan(0);
+			expect(rule['message']).to.have.length.greaterThan(0);
+		})
+
+		it("When using PMD7, the rule description for a cpd rule should give back correct info from PMD 7", async () => {
+			const inputs: Inputs = {
+				rulename: 'copy-paste-detected'
+			}
+			await ruleDescribeAction.run(inputs);
+
+			const rule: AnyJson  = display.getLastStyledObject();
+			expect(rule['name']).to.equal('copy-paste-detected');
+			expect(rule['engine']).to.equal('cpd');
+			expect(rule['isPilot']).to.equal(false);
+			expect(rule['enabled']).to.equal(false);
+			expect(rule['categories']).to.deep.equal(['Copy/Paste Detected']);
+			expect(rule['rulesets']).to.deep.equal([]);
+			expect(rule['languages']).to.deep.equal(['apex', 'java', 'visualforce', 'xml']);
+			expect(rule['description']).to.have.length.greaterThan(0);
+		});
+	});
+});

test/lib/actions/RuleListAction.test.ts

@@ -0,0 +1,72 @@
+import {FakeDisplay} from "../FakeDisplay";
+import {initContainer} from "../../../src/ioc.config";
+import {RuleFilterFactoryImpl} from "../../../src/lib/RuleFilterFactory";
+import {RuleListAction} from "../../../src/lib/actions/RuleListAction";
+import {Pmd7CommandInfo, PmdCommandInfo} from "../../../src/lib/pmd/PmdCommandInfo";
+import {Controller} from "../../../src/Controller";
+import {after} from "mocha";
+import {Inputs} from "../../../src/types";
+import {expect} from "chai";
+import {Ux} from "@salesforce/sf-plugins-core";
+import {PMD7_LIB} from "../../../src/Constants";
+
+describe("Tests for RuleListAction", () => {
+	let display: FakeDisplay;
+	let ruleListAction: RuleListAction;
+	before(() => {
+		initContainer();
+	});
+	beforeEach(() => {
+		display = new FakeDisplay();
+		ruleListAction = new RuleListAction(display, new RuleFilterFactoryImpl());
+	});
+
+	describe("Tests to confirm that PMD7 binary files are invoked when choosing PMD7", () => {
+
+		// TODO: Soon we will have an input flag to control this. Once we do, we can update this to use that instead
+		const originalPmdCommandInfo: PmdCommandInfo = Controller.getActivePmdCommandInfo()
+		before(() => {
+			Controller.setActivePmdCommandInfo(new Pmd7CommandInfo());
+		});
+		after(() => {
+			Controller.setActivePmdCommandInfo(originalPmdCommandInfo);
+		});
+
+		it("When using PMD7, the rule list for the pmd engine should give back rules for PMD 7", async () => {
+			const inputs: Inputs = {
+				engine: ['pmd']
+			}
+			await ruleListAction.run(inputs);
+
+			let tableData: Ux.Table.Data[]  = display.getLastTableData();
+			expect(tableData).to.have.length(67);
+			for (const rowData of tableData) {
+				expect(rowData.engine).to.equal("pmd");
+				expect(rowData.sourcepackage).to.contain(PMD7_LIB);
+				expect(rowData.name).to.have.length.greaterThan(0);
+				expect(rowData.categories).to.have.length.greaterThan(0);
+				expect(rowData.isDfa).to.equal(false);
+				expect(rowData.isPilot).to.equal(false);
+				expect(rowData.languages).to.have.length.greaterThan(0);
+			}
+		})
+
+		it("When using PMD7, the rule list for the cpd engine should give back the copy-paste-detected rule", async () => {
+			const inputs: Inputs = {
+				engine: ['cpd']
+			}
+			await ruleListAction.run(inputs);
+
+			let tableData: Ux.Table.Data[]  = display.getLastTableData();
+			expect(tableData).to.have.length(1);
+			expect(tableData[0].engine).to.equal("cpd");
+			expect(tableData[0].sourcepackage).to.equal("cpd");
+			expect(tableData[0].name).to.equal("copy-paste-detected");
+			expect(tableData[0].categories).to.deep.equal(["Copy/Paste Detected"]);
+			expect(tableData[0].rulesets).to.deep.equal([]);
+			expect(tableData[0].isDfa).to.equal(false);
+			expect(tableData[0].isPilot).to.equal(false);
+			expect(tableData[0].languages).to.deep.equal(['apex', 'java', 'visualforce', 'xml']);
+		});
+	});
+});