private MavenPlugin install(Project project, final MavenPlugin plugin, boolean managed) { MavenPluginFacet plugins = project.getFacet(MavenPluginFacet.class); DependencyFacet deps = project.getFacet(DependencyFacet.class); Coordinate pluginCoordinates = CoordinateBuilder.create() .setGroupId(plugin.getCoordinate().getGroupId()) .setArtifactId(plugin.getCoordinate().getArtifactId()); MavenPlugin managedPlugin = null; if (plugins.hasManagedPlugin(pluginCoordinates)) { managedPlugin = plugins.getManagedPlugin(pluginCoordinates); } MavenPlugin existing = null; // existing represents the plugin(management) as it exists currently throughout the entire // hierarchy if (managed && plugins.hasEffectiveManagedPlugin(pluginCoordinates)) { existing = plugins.getEffectiveManagedPlugin(pluginCoordinates); } else if (plugins.hasEffectivePlugin(pluginCoordinates)) { existing = plugins.getEffectivePlugin(pluginCoordinates); } MavenPlugin filteredPlugin = plugin; // The filtered plugin preserve the hierarchy, by preventing installing properties already // defined with the same // values if (existing != null && preserveHierarchyPrecedence) { filteredPlugin = diff(plugin, existing); } // Preserve direct plugin-management inheritance if (!managed && managedPlugin != null) { // The plugin section does not exists but a plugin management section in the direct pom does filteredPlugin = diff(filteredPlugin, managedPlugin); } MavenPlugin mergedPlugin = filteredPlugin; // merged plugin is a merge with the direct plugin(management) if (managed && managedPlugin != null) { mergedPlugin = plugins.merge(mergedPlugin, managedPlugin); } else if (!managed && plugins.hasPlugin(pluginCoordinates)) { mergedPlugin = plugins.merge(mergedPlugin, plugins.getPlugin(pluginCoordinates)); } // Resolve version String versionToInstall = plugin.getCoordinate().getVersion(); if (mergedPlugin.getCoordinate().getVersion() == null) { // null version means no version was specified or already defined in the hierarchy if (versionToInstall == null) { versionToInstall = promptVersion(deps, pluginCoordinates, null).getVersion(); } } // Install the plugin MavenPluginAdapter pluginToInstall = new MavenPluginAdapter(mergedPlugin); pluginToInstall.setVersion(versionToInstall); if (!managed) { // In case of a direct plugin install // We want it's version being managed in the plugin management section MavenPluginAdapter mavenManagedPlugin = null; if (managedPlugin != null) { // A plugin managemement section already exists, update version mavenManagedPlugin = new MavenPluginAdapter(managedPlugin); mavenManagedPlugin.setVersion(pluginToInstall.getVersion()); } else { // Create a new plugin management, that will handle the minimal configuration: groupId, // artifactId and // version Plugin newManagedPlugin = new Plugin(); newManagedPlugin.setGroupId(pluginToInstall.getGroupId()); newManagedPlugin.setArtifactId(pluginToInstall.getArtifactId()); newManagedPlugin.setVersion(pluginToInstall.getVersion()); mavenManagedPlugin = new MavenPluginAdapter(newManagedPlugin); } // Install the plugin management, if needed addOrUpdatePlugin(deps, plugins, mavenManagedPlugin, true); pluginToInstall.setVersion(null); // handled by the plugin management section } else { if (existing != null && Strings.compare(versionToInstall, existing.getCoordinate().getVersion())) { // Same version in the hierarchy, no need to specify the version pluginToInstall.setVersion(null); } } return addOrUpdatePlugin(deps, plugins, pluginToInstall, managed); }
/** * Remove from the dominant plugin all the properties that are identical in the recessive plugin * If a property exist in the recessive plugin but not in dominant, it will be ignored * <b>Important: the artifactId and groupId properties are not affected</b> */ private MavenPluginAdapter diff(final MavenPlugin dominant, final MavenPlugin recessive) { MavenPluginAdapter merged = new MavenPluginAdapter(dominant); if (Dependencies.areEquivalent(dominant.getCoordinate(), recessive.getCoordinate())) { // Version if (Strings.compare( dominant.getCoordinate().getVersion(), recessive.getCoordinate().getVersion())) { // Remove version as dominant and recessive have the same one merged.setVersion(null); } // Extension if (dominant.isExtensionsEnabled() == recessive.isExtensionsEnabled()) { // Remove extension as dominant and recessive have the same one merged.setExtensions(null); } // Config Map<String, String> cfgElmtsRefMap = new HashMap<>(); Configuration mergedConfiguration = merged.getConfig(); if (dominant.getConfig() != null && recessive.getConfig() != null) { for (ConfigurationElement e : dominant.getConfig().listConfigurationElements()) { // FIXME: recursively do a diff of childrens, if any cfgElmtsRefMap.put(e.getName(), e.toString()); } for (ConfigurationElement e : recessive.getConfig().listConfigurationElements()) { if (cfgElmtsRefMap.containsKey(e.getName())) { if (Strings.compare(cfgElmtsRefMap.get(e.getName()), e.toString())) { // Remove the configuration element as dominant and recessive have the same element mergedConfiguration.removeConfigurationElement(e.getName()); } } } } merged.setConfig(mergedConfiguration); // Executions Map<String, PluginExecution> dominantExec = new MavenPluginAdapter(dominant).getExecutionsAsMap(); Map<String, PluginExecution> recessiveExec = new MavenPluginAdapter(recessive).getExecutionsAsMap(); Map<String, PluginExecution> mergedExec = merged.getExecutionsAsMap(); if (dominantExec != null && recessiveExec != null) { for (Map.Entry<String, PluginExecution> entry : recessiveExec.entrySet()) { PluginExecution pluginExecutionRecessive = entry.getValue(); PluginExecution pluginExecutionDominant = dominantExec.get(entry.getKey()); if (pluginExecutionRecessive != null && pluginExecutionDominant != null) { PluginExecution pluginExecutionMerged = mergedExec.get(entry.getKey()); // Phase if (Strings.compare( pluginExecutionRecessive.getPhase(), pluginExecutionDominant.getPhase())) { // Remove the phase as dominant and recessive are identical pluginExecutionMerged.setPhase(null); } // Goals Map<String, Boolean> hasGoals = new HashMap<>(); for (String goal : pluginExecutionRecessive.getGoals()) { hasGoals.put(goal, new Boolean(true)); } for (String goal : pluginExecutionDominant.getGoals()) { if (hasGoals.get(goal)) { // Remove the goal as dominant and recessive have the same goal pluginExecutionMerged.removeGoal(goal); } } // Configurations Map<String, String> cfgExecElmtsRefMap = new HashMap<>(); if (pluginExecutionRecessive.getConfiguration() != null && pluginExecutionDominant.getConfiguration() != null) { Configuration pluginExecutionRecessiveCfg = new ConfigurationImpl((Xpp3Dom) pluginExecutionRecessive.getConfiguration()); Configuration pluginExecutionDominantCfg = new ConfigurationImpl((Xpp3Dom) pluginExecutionDominant.getConfiguration()); Configuration pluginExecutionMergedCfg = new ConfigurationImpl((Xpp3Dom) pluginExecutionMerged.getConfiguration()); for (ConfigurationElement e : pluginExecutionDominantCfg.listConfigurationElements()) { // FIXME: recursively do a diff of childrens, if any cfgExecElmtsRefMap.put(e.getName(), e.toString()); } for (ConfigurationElement e : pluginExecutionRecessiveCfg.listConfigurationElements()) { if (cfgExecElmtsRefMap.containsKey(e.getName())) { if (Strings.compare(cfgExecElmtsRefMap.get(e.getName()), e.toString())) { // Remove the execution configuration element as dominant and recessive have the // same // element pluginExecutionMergedCfg.removeConfigurationElement(e.getName()); } } } if (!pluginExecutionMergedCfg.hasConfigurationElements()) { pluginExecutionMerged.setConfiguration(null); } try { pluginExecutionMerged.setConfiguration( Xpp3DomBuilder.build( new ByteArrayInputStream(pluginExecutionMergedCfg.toString().getBytes()), "UTF-8")); } catch (Exception ex) { throw new RuntimeException("Exception while parsing configuration", ex); } } } } } } return merged; }