protected ModelBuildingResult build()

in compat/maven-model-builder/src/main/java/org/apache/maven/model/building/DefaultModelBuilder.java [254:426]
120 lines of code
22 McCabe index (conditional complexity)

    protected ModelBuildingResult build(ModelBuildingRequest request, Collection<String> importIds)
            throws ModelBuildingException {
        // phase 1
        DefaultModelBuildingResult result = new DefaultModelBuildingResult();

        DefaultModelProblemCollector problems = new DefaultModelProblemCollector(result);

        // read and validate raw model
        Model inputModel = request.getRawModel();
        if (inputModel == null) {
            inputModel = readModel(request.getModelSource(), request.getPomFile(), request, problems);
        }

        // profile activation
        DefaultProfileActivationContext profileActivationContext = getProfileActivationContext(request, inputModel);

        problems.setSource("(external profiles)");
        List<Profile> activeExternalProfiles =
                profileSelector.getActiveProfiles(request.getProfiles(), profileActivationContext, problems);

        result.setActiveExternalProfiles(activeExternalProfiles);

        if (!activeExternalProfiles.isEmpty()) {
            Properties profileProps = new Properties();
            for (Profile profile : activeExternalProfiles) {
                profileProps.putAll(profile.getProperties());
            }
            profileProps.putAll(profileActivationContext.getUserProperties());
            profileActivationContext.setUserProperties(profileProps);
        }

        problems.setRootModel(inputModel);

        ModelData resultData = new ModelData(request.getModelSource(), inputModel);
        ModelData superData = new ModelData(null, getSuperModel());

        Collection<String> parentIds = new LinkedHashSet<>();
        List<ModelData> lineage = new ArrayList<>();

        for (ModelData currentData = resultData; currentData != null; ) {
            lineage.add(currentData);

            Model rawModel = currentData.getModel();
            currentData.setRawModel(rawModel);

            Model tmpModel = rawModel.clone();
            currentData.setModel(tmpModel);

            problems.setSource(tmpModel);

            // model normalization
            modelNormalizer.mergeDuplicates(tmpModel, request, problems);

            profileActivationContext.setProjectProperties(tmpModel.getProperties());

            List<Profile> interpolatedProfiles = getInterpolatedProfiles(rawModel, profileActivationContext, problems);
            tmpModel.setProfiles(interpolatedProfiles);

            List<Profile> activePomProfiles =
                    profileSelector.getActiveProfiles(tmpModel.getProfiles(), profileActivationContext, problems);

            List<Profile> rawProfiles = new ArrayList<>();
            for (Profile activePomProfile : activePomProfiles) {
                rawProfiles.add(rawModel.getProfiles().get(interpolatedProfiles.indexOf(activePomProfile)));
            }
            currentData.setActiveProfiles(rawProfiles);

            // profile injection
            for (Profile activeProfile : activePomProfiles) {
                profileInjector.injectProfile(tmpModel, activeProfile, request, problems);
            }

            if (currentData == resultData) {
                for (Profile activeProfile : activeExternalProfiles) {
                    profileInjector.injectProfile(tmpModel, activeProfile, request, problems);
                }
            }

            if (currentData == superData) {
                break;
            }

            configureResolver(request.getModelResolver(), tmpModel, problems);

            ModelData parentData = readParent(tmpModel, currentData.getSource(), request, problems);

            if (parentData == null) {
                currentData = superData;
            } else if (currentData == resultData) { // First iteration - add initial id after version resolution.
                currentData.setGroupId(
                        currentData.getRawModel().getGroupId() == null
                                ? parentData.getGroupId()
                                : currentData.getRawModel().getGroupId());

                currentData.setVersion(
                        currentData.getRawModel().getVersion() == null
                                ? parentData.getVersion()
                                : currentData.getRawModel().getVersion());

                currentData.setArtifactId(currentData.getRawModel().getArtifactId());
                parentIds.add(currentData.getId());
                // Reset - only needed for 'getId'.
                currentData.setGroupId(null);
                currentData.setArtifactId(null);
                currentData.setVersion(null);
                currentData = parentData;
            } else if (!parentIds.add(parentData.getId())) {
                StringBuilder message = new StringBuilder("The parents form a cycle: ");
                for (String modelId : parentIds) {
                    message.append(modelId);
                    message.append(" -> ");
                }
                message.append(parentData.getId());

                problems.add(new ModelProblemCollectorRequest(ModelProblem.Severity.FATAL, ModelProblem.Version.BASE)
                        .setMessage(message.toString()));

                throw problems.newModelBuildingException();
            } else {
                currentData = parentData;
            }
        }

        problems.setSource(inputModel);
        checkPluginVersions(lineage, request, problems);

        // inheritance assembly
        assembleInheritance(lineage, request, problems);

        Model resultModel = resultData.getModel();

        problems.setSource(resultModel);
        problems.setRootModel(resultModel);

        // model interpolation
        resultModel = interpolateModel(resultModel, request, problems);
        resultData.setModel(resultModel);

        if (resultModel.getParent() != null) {
            final ModelData parentData = lineage.get(1);
            if (parentData.getVersion() == null || parentData.getVersion().contains("${")) {
                final Model interpolatedParent = interpolateModel(parentData.getModel(), request, problems);
                // parentData.setModel( interpolatedParent );
                parentData.setVersion(interpolatedParent.getVersion());
            }
        }

        // url normalization
        modelUrlNormalizer.normalize(resultModel, request);

        // Now the fully interpolated model is available: reconfigure the resolver
        configureResolver(request.getModelResolver(), resultModel, problems, true);

        resultData.setGroupId(resultModel.getGroupId());
        resultData.setArtifactId(resultModel.getArtifactId());
        resultData.setVersion(resultModel.getVersion());

        result.setEffectiveModel(resultModel);

        for (ModelData currentData : lineage) {
            String modelId = (currentData != superData) ? currentData.getId() : "";

            result.addModelId(modelId);
            result.setActivePomProfiles(modelId, currentData.getActiveProfiles());
            result.setRawModel(modelId, currentData.getRawModel());
        }

        if (!request.isTwoPhaseBuilding()) {
            build(request, result, importIds);
        }

        return result;
    }