Feature/Updated Dependencies for Java & Kotlin Support (Issue #168)

src/detectors/Java/JavaLanguageDetector.ts

@@ -19,21 +19,24 @@ export class JavaLanguageDetector implements ILanguageDetector {
     const result: LanguageAtPath[] = [];
     let packageFiles: Metadata[] = await this.fileInspector.scanFor(fileNameRegExp('pom.xml'), '/');
     const isMaven: boolean = packageFiles.length > 0;
+    const ktFiles: Metadata[] = await this.fileInspector.scanFor(fileExtensionRegExp(['kt', 'kts']), '/');
+    const hasKtFiles = ktFiles.length > 0;
     if (!isMaven) {
       packageFiles = await this.fileInspector.scanFor(fileNameRegExp('build.gradle'), '/');
     }
     if (packageFiles.length > 0) {
       for (const path of packageFiles.map((file) => nodePath.dirname(file.path))) {
-        result.push({ language: ProgrammingLanguage.Java, path });
+        result.push({ language: hasKtFiles ? ProgrammingLanguage.Kotlin : ProgrammingLanguage.Java, path });
       }
     } else {
       const javaFiles: Metadata[] = await this.fileInspector.scanFor(fileExtensionRegExp(['java']), '/');
-      if (javaFiles.length === 0) {
+      if (javaFiles.length === 0 && ktFiles.length === 0) {
         return result;
       }
-      const dirsWithProjects = uniq(javaFiles.map((f) => nodePath.dirname(f.path)));
+      const javaOrKtFiles = javaFiles.concat(ktFiles);
+      const dirsWithProjects = uniq(javaOrKtFiles.map((f) => nodePath.dirname(f.path)));
       const commonPath = sharedSubpath(dirsWithProjects);
-      result.push({ language: ProgrammingLanguage.Java, path: commonPath });
+      result.push({ language: hasKtFiles ? ProgrammingLanguage.Kotlin : ProgrammingLanguage.Java, path: commonPath });
     }
     return result;
   }

src/inspectors/package/JavaPackageInspector.ts

@@ -73,7 +73,8 @@ export class JavaPackageInspector extends PackageInspectorBase {
       for (const xmlDependency of xmlDependencies) {
         const dependencyAttributes = xmlDependency.dependency.values();
         for (const attribute of dependencyAttributes) {
-          this.parsedDependencies.push({ packageName: String(attribute.artifactId.pop()), version: String(attribute.version.pop()) });
+          const packageName = `${attribute.groupId.pop()}:${attribute.artifactId.pop()}`;
+          this.parsedDependencies.push({ packageName, version: String(attribute.version.pop()) });
         }
       }
     });

src/inspectors/package/JavaPackageInspectorMaven.spec.ts

@@ -30,12 +30,12 @@ describe('JavaPackageInspector Maven', () => {
 
   it('Parses the packages correctly', async () => {
     await inspector.init();
-    const pkg = inspector.findPackage('spring-boot-starter-actuator');
+    const pkg = inspector.findPackage('org.springframework.boot:spring-boot-starter-actuator');
 
     if (!pkg) {
       fail();
     } else {
-      expect(pkg.name).toEqual('spring-boot-starter-actuator');
+      expect(pkg.name).toEqual('org.springframework.boot:spring-boot-starter-actuator');
       expect(pkg.requestedVersion.value).toEqual('2.1.8');
       expect(pkg.requestedVersion.major).toEqual('2');
       expect(pkg.requestedVersion.minor).toEqual('1');
@@ -50,11 +50,11 @@ describe('JavaPackageInspector Maven', () => {
       });
 
       it('Returns true package if it exists', () => {
-        expect(inspector.hasPackage('mysql-connector-java')).toBe(true);
+        expect(inspector.hasPackage('mysql:mysql-connector-java')).toBe(true);
       });
 
       it('Returns undefined if the package does not exist', async () => {
-        const pkg = inspector.findPackage('spring-boot-autoconfigure');
+        const pkg = inspector.findPackage('org.springframework.boot:spring-boot-autoconfigure');
         expect(pkg).toBeUndefined();
       });
     });

src/practices/Java/JavaDependenciesVersionMajorLevel.spec.ts

@@ -0,0 +1,46 @@
+import { PracticeEvaluationResult } from '../../model';
+import { JavaDependenciesVersionMajorLevel } from './JavaDependenciesVersionMajorLevel';
+import { createTestContainer, TestContainerContext } from '../../inversify.config';
+import { mockPackage } from '../../test/helpers/mockPackage';
+import { JavaPackageInspector } from '../../inspectors';
+import * as axios from 'axios';
+jest.mock('axios');
+
+describe('JavaDependenciesVersionPractice of Major Level', () => {
+  let practice: JavaDependenciesVersionMajorLevel;
+  let containerCtx: TestContainerContext;
+  const MockedJavaPackageInspector = <jest.Mock<JavaPackageInspector>>(<unknown>JavaPackageInspector);
+  let mockJavaPackageInspector: JavaPackageInspector;
+  const mockedAxios = <jest.Mock>axios.default.get;
+
+  beforeAll(async () => {
+    containerCtx = createTestContainer();
+    containerCtx.container.bind('JavaDependenciesVersionMajorLevel').to(JavaDependenciesVersionMajorLevel);
+    practice = containerCtx.container.get('JavaDependenciesVersionMajorLevel');
+    mockJavaPackageInspector = new MockedJavaPackageInspector();
+  });
+
+  afterEach(async () => {
+    containerCtx.virtualFileSystemService.clearFileSystem();
+    containerCtx.practiceContext.fileInspector!.purgeCache();
+  });
+
+  it('not practicing if newer dependency versions of major level exists', async () => {
+    mockedAxios.mockResolvedValueOnce({ data: { response: { docs: [{ latestVersion: '2.2.1.RELEASE' }] } } });
+    mockJavaPackageInspector.packages = [mockPackage('org.springframework.boot:spring-boot-starter-actuator')];
+    containerCtx.practiceContext.packageInspector!.packages = mockJavaPackageInspector.packages;
+
+    const evaluated = await practice.evaluate(containerCtx.practiceContext);
+    expect(evaluated).toEqual(PracticeEvaluationResult.notPracticing);
+  });
+
+  it('practicing if newest dependency version of major level does not exist', async () => {
+    mockedAxios.mockResolvedValueOnce({ data: { response: { docs: [{ latestVersion: '' }] } } });
+
+    mockJavaPackageInspector.packages = [mockPackage('org.springframework.boot:spring-boot-starter-actuator')];
+    containerCtx.practiceContext.packageInspector!.packages = mockJavaPackageInspector.packages;
+
+    const evaluated = await practice.evaluate(containerCtx.practiceContext);
+    expect(evaluated).toEqual(PracticeEvaluationResult.practicing);
+  });
+});

src/practices/Java/JavaDependenciesVersionMajorLevel.ts

@@ -0,0 +1,59 @@
+import { PracticeContext } from '../../contexts/practice/PracticeContext';
+import { Package } from '../../inspectors/IPackageInspector';
+import { SemverLevel } from '../../inspectors/package/PackageInspectorBase';
+import { PracticeEvaluationResult, PracticeImpact, ProgrammingLanguage } from '../../model';
+import { DxPractice } from '../DxPracticeDecorator';
+import * as axios from 'axios';
+import { DependenciesVersionEvaluationUtils, PkgToUpdate } from '../utils/DependenciesVersionEvaluationUtils';
+import { PracticeBase } from '../PracticeBase';
+import { ReportDetailType } from '../../reporters/ReporterData';
+import qs from 'qs';
+
+@DxPractice({
+  id: 'Java.DependenciesVersionMajorLevel',
+  name: 'Update Dependencies of Major Level',
+  impact: PracticeImpact.small,
+  suggestion: 'Keep the dependencies updated to have all possible features. Use, for example, versions-maven-plugin',
+  reportOnlyOnce: true,
+  url: 'https://www.mojohaus.org/versions-maven-plugin/',
+})
+export class JavaDependenciesVersionMajorLevel extends PracticeBase {
+  async isApplicable(ctx: PracticeContext): Promise<boolean> {
+    return ctx.projectComponent.language === ProgrammingLanguage.Java || ctx.projectComponent.language === ProgrammingLanguage.Kotlin;
+  }
+
+  async evaluate(ctx: PracticeContext): Promise<PracticeEvaluationResult> {
+    if (!ctx.fileInspector || !ctx.packageInspector || !ctx.packageInspector.packages) {
+      return PracticeEvaluationResult.unknown;
+    }
+
+    const pkgs = ctx.packageInspector.packages;
+
+    const result = await JavaDependenciesVersionMajorLevel.searchMavenCentral(pkgs, 5);
+    const pkgsToUpdate = DependenciesVersionEvaluationUtils.packagesToBeUpdated(result, SemverLevel.major, pkgs);
+    this.setData(pkgsToUpdate);
+
+    if (pkgsToUpdate.length > 0) return PracticeEvaluationResult.notPracticing;
+    return PracticeEvaluationResult.practicing;
+  }
+
+  static async searchMavenCentral(pkgs: Package[] | undefined, rows: number) {
+    const latestVersionsJson: { [key: string]: string } = {};
+    const URL = 'http://search.maven.org/solrsearch/select?';
+    if (pkgs) {
+      for (const p of pkgs) {
+        const listOfIds = p.name.split(':', 2);
+        const queryRequest = qs.stringify({ q: `${listOfIds[0]}+AND+a:${listOfIds[1]}`, rows, wt: 'json' }, { encode: false });
+        const listVersionsEndpoint = `${URL}${queryRequest}`;
+        await axios.default.get(listVersionsEndpoint).then((response) => {
+          latestVersionsJson[p.name] = `${response.data.response.docs.pop().latestVersion}`;
+        });
+      }
+    }
+    return latestVersionsJson;
+  }
+
+  setData(pkgsToUpdate: PkgToUpdate[]): void {
+    this.data.details = [{ type: ReportDetailType.table, headers: ['Name', 'New', 'Current'], data: pkgsToUpdate }];
+  }
+}

src/practices/Java/JavaDependenciesVersionMinorPatchLevel.spec.ts

@@ -0,0 +1,47 @@
+import { mockPackage } from '../../test/helpers/mockPackage';
+import { createTestContainer, TestContainerContext } from '../../inversify.config';
+import { PracticeEvaluationResult } from '../../model';
+import { JavaDependenciesVersionMinorPatchLevel } from './JavaDependenciesVersionMinorPatchLevel';
+import { JavaPackageInspector } from '../../inspectors';
+import * as axios from 'axios';
+jest.mock('axios');
+
+describe('JavaDependenciesVersionPractice of Minor and Patch Level', () => {
+  let practice: JavaDependenciesVersionMinorPatchLevel;
+  let containerCtx: TestContainerContext;
+  const MockedJavaPackageInspector = <jest.Mock<JavaPackageInspector>>(<unknown>JavaPackageInspector);
+  let mockJavaPackageInspector: JavaPackageInspector;
+  const mockedAxios = <jest.Mock>axios.default.get;
+
+  beforeAll(async () => {
+    containerCtx = createTestContainer();
+    containerCtx.container.bind('JavaDependenciesVersionMinorPatchLevel').to(JavaDependenciesVersionMinorPatchLevel);
+    practice = containerCtx.container.get('JavaDependenciesVersionMinorPatchLevel');
+    mockJavaPackageInspector = new MockedJavaPackageInspector();
+  });
+
+  afterEach(async () => {
+    containerCtx.virtualFileSystemService.clearFileSystem();
+    containerCtx.practiceContext.fileInspector!.purgeCache();
+  });
+
+  it('not practicing if newer dependency versions of minor or patch level exists', async () => {
+    mockedAxios.mockResolvedValueOnce({ data: { response: { docs: [{ latestVersion: '2.2.1.RELEASE' }] } } });
+
+    mockJavaPackageInspector.packages = [mockPackage('org.springframework.boot:spring-boot-starter-actuator')];
+    containerCtx.practiceContext.packageInspector!.packages = mockJavaPackageInspector.packages;
+
+    const evaluated = await practice.evaluate(containerCtx.practiceContext);
+    expect(evaluated).toEqual(PracticeEvaluationResult.notPracticing);
+  });
+
+  it('practicing if newest dependency version dependency of minor or patch level does not exist', async () => {
+    mockedAxios.mockResolvedValueOnce({ data: { response: { docs: [{ latestVersion: '' }] } } });
+
+    mockJavaPackageInspector.packages = [mockPackage('org.springframework.boot:spring-boot-starter-actuator')];
+    containerCtx.practiceContext.packageInspector!.packages = mockJavaPackageInspector.packages;
+
+    const evaluated = await practice.evaluate(containerCtx.practiceContext);
+    expect(evaluated).toEqual(PracticeEvaluationResult.practicing);
+  });
+});

src/practices/Java/JavaDependenciesVersionMinorPatchLevel.ts

@@ -0,0 +1,41 @@
+import { PracticeContext } from '../../contexts/practice/PracticeContext';
+import { PracticeEvaluationResult, PracticeImpact, ProgrammingLanguage } from '../../model';
+import { DxPractice } from '../DxPracticeDecorator';
+import { IPractice } from '../IPractice';
+import { JavaDependenciesVersionMajorLevel } from './JavaDependenciesVersionMajorLevel';
+import { DependenciesVersionEvaluationUtils } from '../utils/DependenciesVersionEvaluationUtils';
+import { SemverLevel } from '../../inspectors/package/PackageInspectorBase';
+import { flatten } from 'lodash';
+
+@DxPractice({
+  id: 'Java.DependenciesVersionMinorPatchLevel',
+  name: 'Update Dependencies of Minor and Patch Level',
+  impact: PracticeImpact.high,
+  suggestion: 'Keep the dependencies updated to have all possible features. Use, for example, versions-maven-plugin',
+  reportOnlyOnce: true,
+  url: 'https://www.mojohaus.org/versions-maven-plugin/',
+})
+export class JavaDependenciesVersionMinorPatchLevel extends JavaDependenciesVersionMajorLevel implements IPractice {
+  async isApplicable(ctx: PracticeContext): Promise<boolean> {
+    return ctx.projectComponent.language === ProgrammingLanguage.Java || ctx.projectComponent.language === ProgrammingLanguage.Kotlin;
+  }
+
+  async evaluate(ctx: PracticeContext): Promise<PracticeEvaluationResult> {
+    if (!ctx.fileInspector || !ctx.packageInspector || !ctx.packageInspector.packages) {
+      return PracticeEvaluationResult.unknown;
+    }
+
+    const pkgs = ctx.packageInspector.packages;
+
+    const result = await JavaDependenciesVersionMajorLevel.searchMavenCentral(pkgs, 5);
+
+    const patchLevelPkgs = DependenciesVersionEvaluationUtils.packagesToBeUpdated(result, SemverLevel.patch, pkgs);
+    const minorLevelPkgs = DependenciesVersionEvaluationUtils.packagesToBeUpdated(result, SemverLevel.minor, pkgs);
+    this.setData(flatten([patchLevelPkgs, minorLevelPkgs]));
+
+    if (patchLevelPkgs.length > 0 || minorLevelPkgs.length > 0) {
+      return PracticeEvaluationResult.notPracticing;
+    }
+    return PracticeEvaluationResult.practicing;
+  }
+}

src/practices/JavaScript/DependenciesVersionMajorLevel.ts

@@ -1,11 +1,12 @@
 import ncu from 'npm-check-updates';
 import { PracticeContext } from '../../contexts/practice/PracticeContext';
 import { Package } from '../../inspectors/IPackageInspector';
-import { PackageInspectorBase, SemverLevel } from '../../inspectors/package/PackageInspectorBase';
+import { SemverLevel } from '../../inspectors/package/PackageInspectorBase';
 import { PracticeEvaluationResult, PracticeImpact, ProgrammingLanguage } from '../../model';
 import { DxPractice } from '../DxPracticeDecorator';
 import { PracticeBase } from '../PracticeBase';
 import { ReportDetailType } from '../../reporters/ReporterData';
+import { DependenciesVersionEvaluationUtils, PkgToUpdate } from '../utils/DependenciesVersionEvaluationUtils';
 
 @DxPractice({
   id: 'JavaScript.DependenciesVersionMajorLevel',
@@ -29,7 +30,7 @@ export class DependenciesVersionMajorLevelPractice extends PracticeBase {
     const pkgs = ctx.packageInspector.packages;
 
     const result = await this.runNcu(pkgs);
-    const pkgsToUpdate = this.packagesToBeUpdated(result, SemverLevel.major, pkgs);
+    const pkgsToUpdate = DependenciesVersionEvaluationUtils.packagesToBeUpdated(result, SemverLevel.major, pkgs);
     this.setData(pkgsToUpdate);
 
     if (pkgsToUpdate.length > 0) return PracticeEvaluationResult.notPracticing;
@@ -51,29 +52,7 @@ export class DependenciesVersionMajorLevelPractice extends PracticeBase {
     return pkgsToBeUpdated;
   }
 
-  packagesToBeUpdated(pkgsWithNewVersion: { [key: string]: string }, semverLevel: SemverLevel, pkgs: Package[]) {
-    // packages with Major level to be updated
-    const pkgsToUpdate: PkgToUpdate[] = [];
-
-    for (const packageName in pkgsWithNewVersion) {
-      const parsedVersion = PackageInspectorBase.semverToPackageVersion(pkgsWithNewVersion[packageName]);
-      if (parsedVersion) {
-        for (const pkg of pkgs) {
-          if (pkg.name === packageName) {
-            if (parsedVersion[semverLevel] > pkg.lockfileVersion[semverLevel]) {
-              pkgsToUpdate.push({ name: pkg.name, newVersion: parsedVersion.value, currentVersion: pkg.lockfileVersion.value });
-            }
-          }
-        }
-      }
-    }
-
-    return pkgsToUpdate;
-  }
-
   setData(pkgsToUpdate: PkgToUpdate[]): void {
     this.data.details = [{ type: ReportDetailType.table, headers: ['Name', 'New', 'Current'], data: pkgsToUpdate }];
   }
 }
-
-export type PkgToUpdate = { name: string; newVersion: string; currentVersion: string };

src/practices/JavaScript/DependenciesVersionMinorPatchLevel.ts

@@ -3,6 +3,7 @@ import { PracticeEvaluationResult, PracticeImpact, ProgrammingLanguage } from '.
 import { DxPractice } from '../DxPracticeDecorator';
 import { IPractice } from '../IPractice';
 import { DependenciesVersionMajorLevelPractice } from './DependenciesVersionMajorLevel';
+import { DependenciesVersionEvaluationUtils } from '../utils/DependenciesVersionEvaluationUtils';
 import { SemverLevel } from '../../inspectors/package/PackageInspectorBase';
 import { flatten } from 'lodash';
 
@@ -30,8 +31,8 @@ export class DependenciesVersionMinorPatchLevelPractice extends DependenciesVers
 
     const result = await this.runNcu(pkgs);
 
-    const patchLevelPkgs = this.packagesToBeUpdated(result, SemverLevel.patch, pkgs);
-    const minorLevelPkgs = this.packagesToBeUpdated(result, SemverLevel.minor, pkgs);
+    const patchLevelPkgs = DependenciesVersionEvaluationUtils.packagesToBeUpdated(result, SemverLevel.patch, pkgs);
+    const minorLevelPkgs = DependenciesVersionEvaluationUtils.packagesToBeUpdated(result, SemverLevel.minor, pkgs);
     this.setData(flatten([patchLevelPkgs, minorLevelPkgs]));
 
     if (patchLevelPkgs.length > 0 || minorLevelPkgs.length > 0) {

src/practices/index.ts

@@ -23,6 +23,8 @@ import { TsGitignoreCorrectlySetPractice } from './TypeScript/TsGitignoreCorrect
 import { DoesPullRequestsPractice } from './LanguageIndependent/DoesPullRequests';
 import { DependenciesVersionMinorPatchLevelPractice } from './JavaScript/DependenciesVersionMinorPatchLevel';
 import { CorrectCommitMessagesPractice } from './LanguageIndependent/CorrectCommitMessagesPractice';
+import { JavaDependenciesVersionMajorLevel } from './Java/JavaDependenciesVersionMajorLevel';
+import { JavaDependenciesVersionMinorPatchLevel } from './Java/JavaDependenciesVersionMinorPatchLevel';
 import { TimeToSolvePullRequestsPractice } from './LanguageIndependent/TimeToSolvePullRequestsPractice';
 import { ThinPullRequestsPractice } from './LanguageIndependent/ThinPullRequestsPractice';
 
@@ -47,6 +49,8 @@ export const practices = [
   EditorConfigIsPresentPractice,
   DependenciesVersionMajorLevelPractice,
   DependenciesVersionMinorPatchLevelPractice,
+  JavaDependenciesVersionMajorLevel,
+  JavaDependenciesVersionMinorPatchLevel,
   GitignoreIsPresentPractice,
   JsGitignoreCorrectlySetPractice,
   JavaGitignoreCorrectlySetPractice,

src/practices/utils/DependenciesVersionEvaluationUtils.ts

@@ -0,0 +1,24 @@
+import { SemverLevel, Package, PackageInspectorBase } from '../../inspectors';
+
+export class DependenciesVersionEvaluationUtils {
+  static packagesToBeUpdated(pkgsWithNewVersion: { [key: string]: string }, semverLevel: SemverLevel, pkgs: Package[]) {
+    const pkgsToUpdate: PkgToUpdate[] = [];
+
+    for (const packageName in pkgsWithNewVersion) {
+      const parsedVersion = PackageInspectorBase.semverToPackageVersion(pkgsWithNewVersion[packageName]);
+      if (parsedVersion) {
+        for (const pkg of pkgs) {
+          if (pkg.name === packageName) {
+            if (parsedVersion[semverLevel] > pkg.lockfileVersion[semverLevel]) {
+              pkgsToUpdate.push({ name: pkg.name, newVersion: parsedVersion.value, currentVersion: pkg.lockfileVersion.value });
+            }
+          }
+        }
+      }
+    }
+
+    return pkgsToUpdate;
+  }
+}
+
+export type PkgToUpdate = { name: string; newVersion: string; currentVersion: string };