io.quarkus.devtools.codestarts.core.CodestartData Maven / Gradle / Ivy

Go to download
package io.quarkus.devtools.codestarts.core;

import io.quarkus.devtools.codestarts.Codestart;
import io.quarkus.devtools.codestarts.core.CodestartSpec.CodestartDep;
import io.quarkus.devtools.codestarts.utils.NestedMaps;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.LinkedHashSet;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public final class CodestartData {

    private CodestartData() {
    }

    public static Optional getBuildtool(final Map data) {
        return NestedMaps.getValue(data, "codestart-project.buildtool.name");
    }

    public static Map buildCodestartData(final Codestart codestart, final String languageName,
            final Map data) {
        final Optional> value = NestedMaps.getValue(data, codestart.getName());
        Map codestartData = new HashMap<>();
        codestartData.putAll(data);
        NestedMaps.deepMerge(codestartData, codestart.getLocalData(languageName));
        value.ifPresent(map -> NestedMaps.deepMerge(codestartData, map));
        return codestartData;
    }

    public static Map buildCodestartProjectData(Collection baseCodestarts,
            Collection extraCodestarts) {
        final HashMap data = new HashMap<>();
        baseCodestarts.forEach((c) -> data.put("codestart-project." + c.getSpec().getType().toString().toLowerCase() + ".name",
                c.getName()));
        data.put("codestart-project.codestarts", extraCodestarts.stream().map(Codestart::getName).collect(Collectors.toList()));
        return NestedMaps.unflatten(data);
    }

    public static Map buildDependenciesData(Stream codestartsStream, String languageName,
            Collection extensions) {
        final Map> depsData = new HashMap<>();
        final Set dependencies = extensions.stream()
                .map(CodestartDep::new)
                .collect(Collectors.toCollection(LinkedHashSet::new));
        final Set testDependencies = new LinkedHashSet<>();
        codestartsStream
                .flatMap(s -> Stream.of(s.getBaseLanguageSpec(), s.getLanguageSpec(languageName)))
                .forEach(d -> {
                    dependencies.addAll(d.getDependencies());
                    testDependencies.addAll(d.getTestDependencies());
                });
        depsData.put("dependencies", dependencies);
        depsData.put("test-dependencies", testDependencies);
        return Collections.unmodifiableMap(depsData);
    }

}