Issue 215: Use API defaults for a simpler experience

package.json

@@ -163,6 +163,12 @@
           ],
           "scope": "window",
           "description": "Controls if a new sub-folder should be created for the newly generated project."
+        },
+        "spring.initializr.enableSmartDefaults": {
+          "default": false,
+          "type": "boolean",
+          "scope": "window",
+          "description": "Use default values provided by Spring Initializr API for Spring Boot version, language, Java version and packaging."
         }
       }
     }

src/handler/GenerateProjectHandler.ts

@@ -29,10 +29,14 @@ export class GenerateProjectHandler extends BaseHandler {
     constructor(projectType: "maven-project" | "gradle-project", defaults?: IDefaultProjectData) {
         super();
         this.projectType = projectType;
+
+        const settings = vscode.workspace.getConfiguration("spring.initializr");
+
         this.metadata = {
             pickSteps: [],
             defaults: defaults || {},
-            parentFolder: vscode.workspace.getConfiguration("spring.initializr").get<ParentFolder>("parentFolder")
+            parentFolder: settings.get<ParentFolder>("parentFolder"),
+            enableSmartDefaults: settings.get("enableSmartDefaults")
         };
     }
 

src/handler/HandlerInterfaces.ts

@@ -22,6 +22,7 @@ export interface IProjectMetadata {
     pickSteps: IStep[];
     defaults: IDefaultProjectData;
     parentFolder?: ParentFolder;
+    enableSmartDefaults?: boolean;
 }
 
 export interface IDefaultProjectData {
@@ -37,6 +38,7 @@ export interface IDefaultProjectData {
 export interface IHandlerItem<T extends Identifiable> extends QuickPickItem {
     label: string;
     value?: T;
+    default?: boolean;
 }
 
 export interface IPickMetadata<T extends Identifiable> {

src/handler/SpecifyBootVersionStep.ts

@@ -3,7 +3,7 @@
 
 import { instrumentOperationStep, sendInfo } from "vscode-extension-telemetry-wrapper";
 import { serviceManager } from "../model";
-import { BootVersion, MatadataType } from "../model/Metadata";
+import { BootVersion, MetadataType } from "../model/Metadata";
 import { IPickMetadata, IProjectMetadata, IStep } from "./HandlerInterfaces";
 import { SpecifyLanguageStep } from "./SpecifyLanguageStep";
 import { createPickBox } from "./utils";
@@ -29,13 +29,21 @@ export class SpecifyBootVersionStep implements IStep {
     }
 
     private async specifyBootVersion(projectMetadata: IProjectMetadata): Promise<boolean> {
+        const items = await serviceManager.getItems(projectMetadata.serviceUrl, MetadataType.BOOTVERSION);
+
+        if (projectMetadata.enableSmartDefaults === true) {
+            projectMetadata.bootVersion = items.find(x => x.default === true)?.value?.id;
+            return true;
+        }
+
         const pickMetaData: IPickMetadata<BootVersion> = {
             metadata: projectMetadata,
             title: "Spring Initializr: Specify Spring Boot version",
             pickStep: SpecifyBootVersionStep.getInstance(),
             placeholder: "Specify Spring Boot version.",
-            items: serviceManager.getItems(projectMetadata.serviceUrl, MatadataType.BOOTVERSION),
+            items: items,
         };
+
         return await createPickBox(pickMetaData);
     }
 }

src/handler/SpecifyJavaVersionStep.ts

@@ -4,7 +4,7 @@
 import { workspace } from "vscode";
 import { instrumentOperationStep } from "vscode-extension-telemetry-wrapper";
 import { serviceManager } from "../model";
-import { JavaVersion, MatadataType } from "../model/Metadata";
+import { JavaVersion, MetadataType } from "../model/Metadata";
 import { IPickMetadata, IProjectMetadata, IStep } from "./HandlerInterfaces";
 import { SpecifyDependenciesStep } from "./SpecifyDependenciesStep";
 import { createPickBox } from "./utils";
@@ -30,17 +30,27 @@ export class SpecifyJavaVersionStep implements IStep {
 
     private async specifyJavaVersion(projectMetadata: IProjectMetadata): Promise<boolean> {
         const javaVersion: string = projectMetadata.defaults.javaVersion || workspace.getConfiguration("spring.initializr").get<string>("defaultJavaVersion");
+
         if (javaVersion) {
             projectMetadata.javaVersion = javaVersion;
             return true;
         }
+
+        const items = await serviceManager.getItems(projectMetadata.serviceUrl, MetadataType.JAVAVERSION);
+
+        if (projectMetadata.enableSmartDefaults === true) {
+            projectMetadata.javaVersion = items.find(x => x.default === true)?.value?.id;
+            return true;
+        }
+
         const pickMetaData: IPickMetadata<JavaVersion> = {
             metadata: projectMetadata,
             title: "Spring Initializr: Specify Java version",
             pickStep: SpecifyJavaVersionStep.getInstance(),
             placeholder: "Specify Java version.",
-            items: serviceManager.getItems(projectMetadata.serviceUrl, MatadataType.JAVAVERSION),
+            items: items
         };
+
         return await createPickBox(pickMetaData);
     }
 }

src/handler/SpecifyLanguageStep.ts

@@ -4,7 +4,7 @@
 import { workspace } from "vscode";
 import { instrumentOperationStep } from "vscode-extension-telemetry-wrapper";
 import { serviceManager } from "../model";
-import { Language, MatadataType } from "../model/Metadata";
+import { Language, MetadataType } from "../model/Metadata";
 import { IPickMetadata, IProjectMetadata, IStep } from "./HandlerInterfaces";
 import { SpecifyGroupIdStep } from "./SpecifyGroupIdStep";
 import { createPickBox } from "./utils";
@@ -30,17 +30,27 @@ export class SpecifyLanguageStep implements IStep {
 
     private async specifyLanguage(projectMetadata: IProjectMetadata): Promise<boolean> {
         const language: string = projectMetadata.defaults.language || workspace.getConfiguration("spring.initializr").get<string>("defaultLanguage");
+
         if (language) {
             projectMetadata.language = language && language.toLowerCase();
             return true;
         }
+
+        const items = await serviceManager.getItems(projectMetadata.serviceUrl, MetadataType.LANGUAGE);
+
+        if (projectMetadata.enableSmartDefaults === true) {
+            projectMetadata.language = items.find(x => x.default === true)?.label.toLowerCase();
+            return true;
+        }
+
         const pickMetaData: IPickMetadata<Language> = {
             metadata: projectMetadata,
             title: "Spring Initializr: Specify project language",
             pickStep: SpecifyLanguageStep.getInstance(),
             placeholder: "Specify project language.",
-            items: serviceManager.getItems(projectMetadata.serviceUrl, MatadataType.LANGUAGE),
+            items: items
         };
+
         return await createPickBox(pickMetaData);
     }
 }

src/handler/SpecifyPackagingStep.ts

@@ -4,7 +4,7 @@
 import { workspace } from "vscode";
 import { instrumentOperationStep } from "vscode-extension-telemetry-wrapper";
 import { serviceManager } from "../model";
-import { MatadataType, Packaging } from "../model/Metadata";
+import { MetadataType, Packaging } from "../model/Metadata";
 import { IPickMetadata, IProjectMetadata, IStep } from "./HandlerInterfaces";
 import { SpecifyJavaVersionStep } from "./SpecifyJavaVersionStep";
 import { createPickBox } from "./utils";
@@ -30,17 +30,27 @@ export class SpecifyPackagingStep implements IStep {
 
     private async specifyPackaging(projectMetadata: IProjectMetadata): Promise<boolean> {
         const packaging: string = projectMetadata.defaults.packaging || workspace.getConfiguration("spring.initializr").get<string>("defaultPackaging");
+
         if (packaging) {
             projectMetadata.packaging = packaging && packaging.toLowerCase();
             return true;
         }
+
+        const items = await serviceManager.getItems(projectMetadata.serviceUrl, MetadataType.PACKAGING);
+
+        if (projectMetadata.enableSmartDefaults === true) {
+            projectMetadata.packaging = items.find(x => x.default === true)?.label?.toLowerCase();
+            return true;
+        }
+
         const pickMetaData: IPickMetadata<Packaging> = {
             metadata: projectMetadata,
             title: "Spring Initializr: Specify packaging type",
             pickStep: SpecifyPackagingStep.getInstance(),
             placeholder: "Specify packaging type.",
-            items: serviceManager.getItems(projectMetadata.serviceUrl, MatadataType.PACKAGING),
+            items: items
         };
+
         return await createPickBox(pickMetaData);
     }
 }

src/model/Metadata.ts

@@ -13,7 +13,7 @@ export interface Metadata {
     type: Category<ProjectType>;
 }
 
-export enum MatadataType {
+export enum MetadataType {
     BOOTVERSION,
     JAVAVERSION,
     LANGUAGE,

src/model/ServiceManager.ts

@@ -6,7 +6,7 @@ import { IDependency, IStarters } from ".";
 import { IHandlerItem } from "../handler/HandlerInterfaces";
 import { downloadFile } from "../Utils";
 import { matchRange } from "../Utils/VersionHelper";
-import { DependencyGroup, Identifiable, MatadataType, Metadata } from "./Metadata";
+import { DependencyGroup, Identifiable, MetadataType, Metadata } from "./Metadata";
 
 /**
  * Prefer v2.2 and fallback to v2.1
@@ -17,44 +17,57 @@ const METADATA_HEADERS = { Accept: "application/vnd.initializr.v2.2+json,applica
 class ServiceManager {
     private metadataMap: Map<string, Metadata> = new Map();
 
-    public async getItems<T extends Identifiable>(serviceUrl: string, type: MatadataType): Promise<Array<IHandlerItem<T>>> {
+    public async getItems<T extends Identifiable>(serviceUrl: string, type: MetadataType): Promise<Array<IHandlerItem<T>>> {
         const metadata = await this.ensureMetadata(serviceUrl);
         if (!metadata) {
             throw new Error("Failed to fetch metadata.");
         }
         let defaultLabel: string;
         let values: any[];
         switch (type) {
-            case MatadataType.BOOTVERSION:
+            case MetadataType.BOOTVERSION:
                 defaultLabel = metadata.bootVersion.default;
                 values = metadata.bootVersion.values;
                 break;
-            case MatadataType.JAVAVERSION:
+            case MetadataType.JAVAVERSION:
                 defaultLabel = metadata.javaVersion.default;
                 values = metadata.javaVersion.values;
                 break;
-            case MatadataType.LANGUAGE:
+            case MetadataType.LANGUAGE:
                 defaultLabel = metadata.language.default;
                 values = metadata.language.values;
                 break;
-            case MatadataType.PACKAGING:
+            case MetadataType.PACKAGING:
                 defaultLabel = metadata.packaging.default;
                 values = metadata.packaging.values;
                 break;
             default:
                 throw new Error("Invalid metadata type.");
         }
 
-        const sortedValues = values.filter(x => x.id === defaultLabel).concat(values.filter(x => x.id !== defaultLabel));
+        const defaultValues = values.filter(x => x.id === defaultLabel);
+        const nonDefaultValues = values.filter(x => x.id !== defaultLabel);
+
+        let mappedDefault: Array<IHandlerItem<T>> = this.mapValues(defaultValues, type, true);
+        let mappedNonDefault: Array<IHandlerItem<T>> = this.mapValues(nonDefaultValues, type, false);
+
+        return mappedDefault.concat(mappedNonDefault);
+    }
+
+    private mapValues<T extends Identifiable>(
+        items: any[],
+        type: MetadataType,
+        isDefault: boolean
+    ): Array<IHandlerItem<T>> {
         switch (type) {
-            case MatadataType.BOOTVERSION:
-                return sortedValues.map(v => ({ value: v, label: v.name }));
-            case MatadataType.JAVAVERSION:
-                return sortedValues.map(v => ({ value: v, label: v.name }));
+            case MetadataType.BOOTVERSION:
+                return items.map(v => ({ value: v, label: v.name, default: isDefault}))
+            case MetadataType.JAVAVERSION:
+                return items.map(v => ({ value: v, label: v.name, default: isDefault }));
             default:
-                return sortedValues.map(v => ({ label: v.name }));
+                return items.map(v => ({ label: v.name, default: isDefault }));
         }
-    }
+    } 
 
     public async getAvailableDependencies(serviceUrl: string, bootVersion: string): Promise<IDependency[]> {
         const metadata = await this.ensureMetadata(serviceUrl);