protected Map resolveModel()

in initializr-generator/src/main/java/io/spring/initializr/generator/ProjectGenerator.java [351:498]
113 lines of code
18 McCabe index (conditional complexity)

	protected Map<String, Object> resolveModel(ProjectRequest originalRequest) {
		Assert.notNull(originalRequest.getBootVersion(), "boot version must not be null");
		Map<String, Object> model = new LinkedHashMap<>();
		InitializrMetadata metadata = this.metadataProvider.get();

		ProjectRequest request = this.requestResolver.resolve(originalRequest, metadata);

		// request resolved so we can log what has been requested
		Version bootVersion = Version.safeParse(request.getBootVersion());
		List<Dependency> dependencies = request.getResolvedDependencies();
		List<String> dependencyIds = dependencies.stream().map(Dependency::getId)
				.collect(Collectors.toList());
		log.info("Processing request{type=" + request.getType() + ", dependencies="
				+ dependencyIds);

		if (isWar(request)) {
			model.put("war", true);
		}

		// Kotlin supported as of M6
		final boolean kotlinSupport = VERSION_2_0_0_M6.compareTo(bootVersion) <= 0;
		model.put("kotlinSupport", kotlinSupport);

		if (isMavenBuild(request)) {
			model.put("mavenBuild", true);
			ParentPom parentPom = metadata.getConfiguration().getEnv().getMaven()
					.resolveParentPom(request.getBootVersion());
			if (parentPom.isIncludeSpringBootBom()
					&& !request.getBoms().containsKey("spring-boot")) {
				request.getBoms().put("spring-boot", metadata.createSpringBootBom(
						request.getBootVersion(), "spring-boot.version"));
			}

			model.put("mavenParentGroupId", parentPom.getGroupId());
			model.put("mavenParentArtifactId", parentPom.getArtifactId());
			model.put("mavenParentVersion", parentPom.getVersion());
			model.put("includeSpringBootBom", parentPom.isIncludeSpringBootBom());
		}

		model.put("repositoryValues", request.getRepositories().entrySet());
		if (!request.getRepositories().isEmpty()) {
			model.put("hasRepositories", true);
		}

		List<Map<String, String>> resolvedBoms = buildResolvedBoms(request);
		model.put("resolvedBoms", resolvedBoms);
		ArrayList<Map<String, String>> reversedBoms = new ArrayList<>(resolvedBoms);
		Collections.reverse(reversedBoms);
		model.put("reversedBoms", reversedBoms);

		model.put("compileDependencies",
				filterDependencies(dependencies, Dependency.SCOPE_COMPILE));
		model.put("runtimeDependencies",
				filterDependencies(dependencies, Dependency.SCOPE_RUNTIME));
		model.put("compileOnlyDependencies",
				filterDependencies(dependencies, Dependency.SCOPE_COMPILE_ONLY));
		model.put("annotationProcessorDependencies",
				filterDependencies(dependencies, Dependency.SCOPE_ANNOTATION_PROCESSOR));
		model.put("providedDependencies",
				filterDependencies(dependencies, Dependency.SCOPE_PROVIDED));
		model.put("testDependencies",
				filterDependencies(dependencies, Dependency.SCOPE_TEST));

		request.getBoms().forEach((k, v) -> {
			if (v.getVersionProperty() != null) {
				request.getBuildProperties().getVersions()
						.computeIfAbsent(v.getVersionProperty(), (key) -> v::getVersion);
			}
		});

		Map<String, String> versions = new LinkedHashMap<>();
		model.put("buildPropertiesVersions", versions.entrySet());
		request.getBuildProperties().getVersions().forEach(
				(k, v) -> versions.put(computeVersionProperty(request, k), v.get()));
		Map<String, String> gradle = new LinkedHashMap<>();
		model.put("buildPropertiesGradle", gradle.entrySet());
		request.getBuildProperties().getGradle()
				.forEach((k, v) -> gradle.put(k, v.get()));
		Map<String, String> maven = new LinkedHashMap<>();
		model.put("buildPropertiesMaven", maven.entrySet());
		request.getBuildProperties().getMaven().forEach((k, v) -> maven.put(k, v.get()));

		// Add various versions
		model.put("dependencyManagementPluginVersion", metadata.getConfiguration()
				.getEnv().getGradle().getDependencyManagementPluginVersion());
		if ("kotlin".equals(request.getLanguage())) {
			model.put("kotlinVersion", metadata.getConfiguration().getEnv().getKotlin()
					.resolveKotlinVersion(bootVersion));
			model.put("kotlin", true);
		}
		if ("groovy".equals(request.getLanguage())) {
			model.put("groovy", true);
		}

		model.put("isRelease", request.getBootVersion().contains("RELEASE"));
		setupApplicationModel(request, model);

		// Gradle plugin has changed as from 1.3.0
		model.put("bootOneThreeAvailable", VERSION_1_3_0_M1.compareTo(bootVersion) <= 0);

		final boolean bootTwoZeroAvailable = VERSION_2_0_0_M1.compareTo(bootVersion) <= 0;
		model.put("bootTwoZeroAvailable", bootTwoZeroAvailable);

		// Gradle plugin has changed again as from 1.4.2
		model.put("springBootPluginName", (VERSION_1_4_2_M1.compareTo(bootVersion) <= 0)
				? "org.springframework.boot" : "spring-boot");

		// New testing stuff
		model.put("newTestInfrastructure", isNewTestInfrastructureAvailable(request));

		// Servlet Initializer
		model.put("servletInitializrImport", new Imports(request.getLanguage())
				.add(getServletInitializrClass(request)).toString());

		// Kotlin-specific dep
		model.put("kotlinStdlibArtifactId", getKotlinStdlibArtifactId(request));

		// Java versions
		model.put("java8OrLater", isJava8OrLater(request));

		// Facets
		request.getFacets().forEach((facet) -> model.put("facets." + facet, true));

		// Append the project request to the model
		BeanWrapperImpl bean = new BeanWrapperImpl(request);
		for (PropertyDescriptor descriptor : bean.getPropertyDescriptors()) {
			if (bean.isReadableProperty(descriptor.getName())) {
				model.put(descriptor.getName(),
						bean.getPropertyValue(descriptor.getName()));
			}
		}
		if (!request.getBoms().isEmpty()) {
			model.put("hasBoms", true);
		}

		if (isGradleBuild(request)) {
			model.put("gradleCompileConfig",
					bootTwoZeroAvailable ? "implementation" : "compile");
			model.put("gradleRuntimeConfig",
					bootTwoZeroAvailable ? "runtimeOnly" : "runtime");
			model.put("gradleTestCompileConfig",
					bootTwoZeroAvailable ? "testImplementation" : "testCompile");
			model.put("gradleTestRuntimeConfig",
					bootTwoZeroAvailable ? "testRuntimeOnly" : "testRuntime");
		}

		return model;
	}