1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19 package org.apache.maven.impl.model;
20
21 import java.util.ArrayList;
22 import java.util.Collections;
23 import java.util.LinkedHashMap;
24 import java.util.List;
25 import java.util.Map;
26 import java.util.WeakHashMap;
27 import java.util.concurrent.ConcurrentHashMap;
28
29 import org.apache.maven.api.di.Named;
30 import org.apache.maven.api.di.Singleton;
31 import org.apache.maven.api.model.Build;
32 import org.apache.maven.api.model.BuildBase;
33 import org.apache.maven.api.model.Model;
34 import org.apache.maven.api.model.ModelBase;
35 import org.apache.maven.api.model.Plugin;
36 import org.apache.maven.api.model.PluginContainer;
37 import org.apache.maven.api.model.PluginExecution;
38 import org.apache.maven.api.model.Profile;
39 import org.apache.maven.api.model.ReportPlugin;
40 import org.apache.maven.api.model.ReportSet;
41 import org.apache.maven.api.model.Reporting;
42 import org.apache.maven.api.model.Repository;
43 import org.apache.maven.api.model.RepositoryBase;
44 import org.apache.maven.api.services.ModelBuilderRequest;
45 import org.apache.maven.api.services.ModelProblemCollector;
46 import org.apache.maven.api.services.model.ProfileInjector;
47
48
49
50
51
52 @Named
53 @Singleton
54 public class DefaultProfileInjector implements ProfileInjector {
55
56 private static final Map<Model, Map<List<Profile>, Model>> CACHE = Collections.synchronizedMap(new WeakHashMap<>());
57
58
59
60
61 private static final Model KEY = Model.newInstance();
62
63 private final ProfileModelMerger merger = new ProfileModelMerger();
64
65 @Override
66 public Model injectProfiles(
67 Model model, List<Profile> profiles, ModelBuilderRequest request, ModelProblemCollector problems) {
68 Model result = CACHE.computeIfAbsent(model, k -> new ConcurrentHashMap<>())
69 .computeIfAbsent(profiles, l -> doInjectProfiles(model, profiles));
70 return result == KEY ? model : result;
71 }
72
73 private Model doInjectProfiles(Model model, List<Profile> profiles) {
74 Model orgModel = model;
75 for (Profile profile : profiles) {
76 if (profile != null) {
77 Model.Builder builder = Model.newBuilder(model);
78 merger.mergeModelBase(builder, model, profile);
79
80 if (profile.getBuild() != null) {
81 Build build = model.getBuild() != null ? model.getBuild() : Build.newInstance();
82 Build.Builder bbuilder = Build.newBuilder(build);
83 merger.mergeBuildBase(bbuilder, build, profile.getBuild());
84 builder.build(bbuilder.build());
85 }
86
87 model = builder.build();
88 }
89 }
90 return model == orgModel ? KEY : model;
91 }
92
93
94
95
96 protected static class ProfileModelMerger extends MavenModelMerger {
97
98 public void mergeModelBase(ModelBase.Builder builder, ModelBase target, ModelBase source) {
99 mergeModelBase(builder, target, source, true, Collections.emptyMap());
100 }
101
102 public void mergeBuildBase(BuildBase.Builder builder, BuildBase target, BuildBase source) {
103 mergeBuildBase(builder, target, source, true, Collections.emptyMap());
104 }
105
106 @Override
107 protected void mergePluginContainer_Plugins(
108 PluginContainer.Builder builder,
109 PluginContainer target,
110 PluginContainer source,
111 boolean sourceDominant,
112 Map<Object, Object> context) {
113 List<Plugin> src = source.getPlugins();
114 if (!src.isEmpty()) {
115 List<Plugin> tgt = target.getPlugins();
116 Map<Object, Plugin> master = new LinkedHashMap<>(tgt.size() * 2);
117
118 for (Plugin element : tgt) {
119 Object key = getPluginKey().apply(element);
120 master.put(key, element);
121 }
122
123 Map<Object, List<Plugin>> predecessors = new LinkedHashMap<>();
124 List<Plugin> pending = new ArrayList<>();
125 for (Plugin element : src) {
126 Object key = getPluginKey().apply(element);
127 Plugin existing = master.get(key);
128 if (existing != null) {
129 existing = mergePlugin(existing, element, sourceDominant, context);
130 master.put(key, existing);
131 if (!pending.isEmpty()) {
132 predecessors.put(key, pending);
133 pending = new ArrayList<>();
134 }
135 } else {
136 pending.add(element);
137 }
138 }
139
140 List<Plugin> result = new ArrayList<>(src.size() + tgt.size());
141 for (Map.Entry<Object, Plugin> entry : master.entrySet()) {
142 List<Plugin> pre = predecessors.get(entry.getKey());
143 if (pre != null) {
144 result.addAll(pre);
145 }
146 result.add(entry.getValue());
147 }
148 result.addAll(pending);
149
150 builder.plugins(result);
151 }
152 }
153
154 @Override
155 protected void mergePlugin_Executions(
156 Plugin.Builder builder,
157 Plugin target,
158 Plugin source,
159 boolean sourceDominant,
160 Map<Object, Object> context) {
161 List<PluginExecution> src = source.getExecutions();
162 if (!src.isEmpty()) {
163 List<PluginExecution> tgt = target.getExecutions();
164 Map<Object, PluginExecution> merged = new LinkedHashMap<>((src.size() + tgt.size()) * 2);
165
166 for (PluginExecution element : tgt) {
167 Object key = getPluginExecutionKey().apply(element);
168 merged.put(key, element);
169 }
170
171 for (PluginExecution element : src) {
172 Object key = getPluginExecutionKey().apply(element);
173 PluginExecution existing = merged.get(key);
174 if (existing != null) {
175 element = mergePluginExecution(existing, element, sourceDominant, context);
176 }
177 merged.put(key, element);
178 }
179
180 builder.executions(merged.values());
181 }
182 }
183
184 @Override
185 protected void mergeReporting_Plugins(
186 Reporting.Builder builder,
187 Reporting target,
188 Reporting source,
189 boolean sourceDominant,
190 Map<Object, Object> context) {
191 List<ReportPlugin> src = source.getPlugins();
192 if (!src.isEmpty()) {
193 List<ReportPlugin> tgt = target.getPlugins();
194 Map<Object, ReportPlugin> merged = new LinkedHashMap<>((src.size() + tgt.size()) * 2);
195
196 for (ReportPlugin element : tgt) {
197 Object key = getReportPluginKey().apply(element);
198 merged.put(key, element);
199 }
200
201 for (ReportPlugin element : src) {
202 Object key = getReportPluginKey().apply(element);
203 ReportPlugin existing = merged.get(key);
204 if (existing != null) {
205 element = mergeReportPlugin(existing, element, sourceDominant, context);
206 }
207 merged.put(key, element);
208 }
209
210 builder.plugins(merged.values());
211 }
212 }
213
214 @Override
215 protected void mergeReportPlugin_ReportSets(
216 ReportPlugin.Builder builder,
217 ReportPlugin target,
218 ReportPlugin source,
219 boolean sourceDominant,
220 Map<Object, Object> context) {
221 List<ReportSet> src = source.getReportSets();
222 if (!src.isEmpty()) {
223 List<ReportSet> tgt = target.getReportSets();
224 Map<Object, ReportSet> merged = new LinkedHashMap<>((src.size() + tgt.size()) * 2);
225
226 for (ReportSet element : tgt) {
227 Object key = getReportSetKey().apply(element);
228 merged.put(key, element);
229 }
230
231 for (ReportSet element : src) {
232 Object key = getReportSetKey().apply(element);
233 ReportSet existing = merged.get(key);
234 if (existing != null) {
235 element = mergeReportSet(existing, element, sourceDominant, context);
236 }
237 merged.put(key, element);
238 }
239
240 builder.reportSets(merged.values());
241 }
242 }
243
244 @Override
245 protected KeyComputer<Repository> getRepositoryKey() {
246 return RepositoryBase::getId;
247 }
248 }
249 }