project.getTasks().named(BasePlugin.ASSEMBLE_TASK_NAME).configure(task -> task.dependsOn("shadowJar"));
        });
    }

    private static void configureJarManifest(Project project) {
        project.getPlugins().withType(InfoBrokerPlugin.class).whenPluginAdded(manifestPlugin -> {
            manifestPlugin.add("Module-Origin", toStringable(BuildParams::getGitOrigin));

            }
        }

        private void visit(BuildBase build) {
            if (build != null) {
                String org, val;
                // Plugins
                for (Plugin plugin : build.getPlugins()) {
                    visit(plugin);
                }
                // PluginManagement
                visit(build.getPluginManagement());
                // DefaultGoal

        updateDocumentationExtension(project, documentationExtension);
        configurePlugin(project, documentationExtension);
    }

    private static void applyPlugin(Project project) {
        project.getPlugins().apply(DokkaPlugin.class);
    }

    private static void updateDocumentationExtension(Project project, GradleDocumentationExtension extension) {
        TaskProvider<Task> generateTask = project.getTasks().named(TASK_NAME);

    }

    /**
     * @return a Map of plugins field with {@code Plugins#getKey()} as key
     * @see Plugin#getKey()
     */
    public Map<String, Plugin> getPluginsAsMap() {
        return getPlugins().stream().collect(Collectors.toMap(plugin -> plugin.getKey(), plugin -> plugin));
    }
            ]]>
          </code>
        </codeSegment>
        <codeSegment>
          <version>4.1.0+</version>

        Build build = effectiveModel.getBuild();
        if (build != null) {
            // Check build/plugins - these are the actual plugins used in the build
            for (Plugin plugin : build.getPlugins()) {
                String pluginKey = getPluginKey(plugin);
                PluginUpgrade upgrade = pluginUpgrades.get(pluginKey);
                if (upgrade != null) {

        }
    }

    protected void mergeReporting_Plugins(
            Reporting target, Reporting source, boolean sourceDominant, Map<Object, Object> context) {
        target.setPlugins(
                merge(target.getPlugins(), source.getPlugins(), sourceDominant, new ReportPluginKeyComputer()));
    }

    protected void mergeReportPlugin(

            Model model = lineage.get(i).getModel();
            Build build = model.getBuild();
            if (build != null) {
                for (Plugin plugin : build.getPlugins()) {
                    String key = plugin.getKey();
                    if (versions.get(key) == null) {
                        versions.put(key, plugin.getVersion());
                        plugins.put(key, plugin);

    public org.apache.maven.plugin.MojoExecution getDelegate() {
        return delegate;
    }

    @Override
    public Plugin getPlugin() {
        return new Plugin() {
            @Override
            public org.apache.maven.api.model.Plugin getModel() {
                return delegate.getPlugin().getDelegate();
            }

            @Override
            public PluginDescriptor getDescriptor() {

    }

    public String getLifecyclePhase() {
        return mojoExecution.getLifecyclePhase();
    }

    public Plugin getPlugin() {
        final MojoDescriptor mojoDescriptor = getMojoExecution().getMojoDescriptor();
        return mojoDescriptor.getPluginDescriptor().getPlugin();
    }

    @Override
    public String toString() {

        MojoDescriptor mojoDescriptor = execution.getMojoDescriptor();

        if (mojoDescriptor == null) {
            mojoDescriptor = pluginManager.getMojoDescriptor(
                    execution.getPlugin(),
                    execution.getGoal(),
                    project.getRemotePluginRepositories(),
                    session.getRepositorySession());

            execution.setMojoDescriptor(mojoDescriptor);