nebula-plugins / nebula-dependency-recommender-plugin / 320

pending completion

Build # 320

Build Type

Pull #87

travis-ci

Committed by

web-flow

Commit Message

Gradle 5.0 Compatibility

ClosureBackedAction was moved to a new package in gradle/gradle@b16479080,
which will first be released in Gradle 5.0. Switching to ConfigureUtil, since there is a
note in the Javadoc recommending using org.gradle.util.ConfigureUtil anyway.

Pull Request Pull Request #87: Gradle 5.0 Compatibility

Run Details

4 of 4 new or added lines in 1 file covered. (100.0%)

424 of 524 relevant lines covered (80.92%)

0.81 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

61.05

/src/main/groovy/netflix/nebula/dependency/recommender/provider/RecommendationProviderContainer.java

/*
 * Copyright 2014-2017 Netflix, Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *    http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package netflix.nebula.dependency.recommender.provider;

import groovy.lang.Closure;
import netflix.nebula.dependency.recommender.DependencyRecommendationsPlugin;
import netflix.nebula.dependency.recommender.RecommendationStrategies;
import org.gradle.api.Action;
import org.gradle.api.GradleException;
import org.gradle.api.Namer;
import org.gradle.api.Project;
import org.gradle.api.internal.ConfigureByMapAction;
import org.gradle.api.internal.DefaultNamedDomainObjectList;
import org.gradle.util.ConfigureUtil;

import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

import static netflix.nebula.dependency.recommender.DependencyRecommendationsPlugin.CORE_BOM_SUPPORT_ENABLED;

public class RecommendationProviderContainer extends DefaultNamedDomainObjectList<RecommendationProvider> {

    private Project project;
    private RecommendationStrategies strategy = RecommendationStrategies.ConflictResolved;
    private MavenBomRecommendationProvider mavenBomProvider;
    private Boolean strictMode = false;
    private Set<String> excludedConfigurations = new HashSet<>();
    private Set<String> reasons = new HashSet<>();
    
    // Make strategies available without import
    public static final RecommendationStrategies OverrideTransitives = RecommendationStrategies.OverrideTransitives;
    public static final RecommendationStrategies ConflictResolved = RecommendationStrategies.ConflictResolved;

    private final Action<? super RecommendationProvider> addLastAction = new Action<RecommendationProvider>() {
        public void execute(RecommendationProvider r) {
            RecommendationProviderContainer.super.add(r);
        }
    };

    public RecommendationProviderContainer(Project project) {
        super(RecommendationProvider.class, null, new RecommendationProviderNamer());
        this.project = project;
        this.mavenBomProvider = new MavenBomRecommendationProvider(this.project, DependencyRecommendationsPlugin.NEBULA_RECOMMENDER_BOM, this.reasons);
        this.add(this.mavenBomProvider);
    }

    private static class RecommendationProviderNamer implements Namer<RecommendationProvider> {
        public String determineName(RecommendationProvider r) {
            return r.getName();
        }
    }

    public <T extends RecommendationProvider> T addProvider(T provider, Action<? super T> configureAction) {
        configureAction.execute(provider);
        assertCanAdd(provider.getName());
        addLastAction.execute(provider);
        return provider;
    }

    public <T extends RecommendationProvider> T addFirst(T provider) {
        remove(provider);
        super.add(0, provider);
        return provider;
    }

    public PropertyFileRecommendationProvider propertiesFile(Map<String, ?> args) {
        ensureCoreBomSupportNotEnabled("propertiesFile");
        String message = "nebula.dependency-recommender uses a properties file: " + args.get("file");
        reasons.add(message);
        Map<String, Object> modifiedArgs = new HashMap<String, Object>(args);
        return addProvider(new PropertyFileRecommendationProvider(project), new ConfigureByMapAction<PropertyFileRecommendationProvider>(modifiedArgs));
    }

    public PropertyFileRecommendationProvider propertiesFile(Closure closure) {
        ensureCoreBomSupportNotEnabled("propertiesFile");
        String message = "nebula.dependency-recommender uses a properties file";
        reasons.add(message);
        return addProvider(new PropertyFileRecommendationProvider(project), ConfigureUtil.<PropertyFileRecommendationProvider>configureUsing(closure));
    }

    public MavenBomRecommendationProvider mavenBom(Map<String, ?> args) {
        Object dependencyNotation = args.get("module");
        if(dependencyNotation == null) {
            throw new IllegalArgumentException("Module may not be null");
        }

        if (!CORE_BOM_SUPPORT_ENABLED) {
            if (Map.class.isAssignableFrom(dependencyNotation.getClass())) {
                ((Map) dependencyNotation).put("ext", "pom");
            } else if (!dependencyNotation.toString().endsWith("@pom")) {
                dependencyNotation = dependencyNotation.toString() + "@pom";
            }
        }
        project.getDependencies().add(DependencyRecommendationsPlugin.NEBULA_RECOMMENDER_BOM, dependencyNotation);

        return mavenBomProvider;
    }

    public IvyRecommendationProvider ivyXml(Map<String, ?> args) {
        ensureCoreBomSupportNotEnabled("ivyXml");
        String message = "nebula.dependency-recommender uses a ivyXml: " + args.get("module");
        reasons.add(message);
        Map<String, Object> modifiedArgs = new HashMap<String, Object>(args);
        return addProvider(new IvyRecommendationProvider(project), new ConfigureByMapAction<IvyRecommendationProvider>(modifiedArgs));
    }

    public IvyRecommendationProvider ivyXml(Closure closure) {
        ensureCoreBomSupportNotEnabled("ivyXml");
        String message = "nebula.dependency-recommender uses a ivyXml";
        reasons.add(message);
        return addProvider(new IvyRecommendationProvider(project), ConfigureUtil.<IvyRecommendationProvider>configureUsing(closure));
    }

    public DependencyLockProvider dependencyLock(Map<String, ?> args) {
        ensureCoreBomSupportNotEnabled("dependencyLock");
        String message = "nebula.dependency-recommender uses a dependency lock: " + args.get("module");
        reasons.add(message);
        Map<String, Object> modifiedArgs = new HashMap<String, Object>(args);
        return addProvider(new DependencyLockProvider(project), new ConfigureByMapAction<DependencyLockProvider>(modifiedArgs));
    }

    public DependencyLockProvider dependencyLock(Closure closure) {
        ensureCoreBomSupportNotEnabled("dependencyLock");
        String message = "nebula.dependency-recommender uses a dependency lock for recommendations";
        reasons.add(message);
        return addProvider(new DependencyLockProvider(project), ConfigureUtil.<DependencyLockProvider>configureUsing(closure));
    }

    public MapRecommendationProvider map(Map<String, ?> args) {
        ensureCoreBomSupportNotEnabled("map");
        String message = "nebula.dependency-recommender uses a provided map for recommendations";
        reasons.add(message);
        Map<String, Object> modifiedArgs = new HashMap<String, Object>(args);
        return addProvider(new MapRecommendationProvider(), new ConfigureByMapAction<MapRecommendationProvider>(modifiedArgs));
    }

    public MapRecommendationProvider map(Closure closure) {
        ensureCoreBomSupportNotEnabled("map");
        String message = "nebula.dependency-recommender uses a provided map for recommendations";
        reasons.add(message);
        return addProvider(new MapRecommendationProvider(), ConfigureUtil.<MapRecommendationProvider>configureUsing(closure));
    }

    public CustomRecommendationProvider addProvider(Closure closure) {
        ensureCoreBomSupportNotEnabled("addProvider");
        String message = "nebula.dependency-recommender uses a CustomRecommendationProvider";
        reasons.add(message);
        return addProvider(new CustomRecommendationProvider(closure), new Action<CustomRecommendationProvider>() {
            @Override
            public void execute(CustomRecommendationProvider customRecommendationProvider) {
            }
        });
    }

    public MavenBomRecommendationProvider getMavenBomProvider() {
        return mavenBomProvider;
    }

    public String getRecommendedVersion(String group, String name) {
        // providers are queried in LIFO order
        for (int i = size()-1; i >= 0; i--) {
            try {
                String version = get(i).getVersion(group, name);
                if (version != null) {
                    return version;
                }
            } catch(Exception e) {
                project.getLogger().error("Exception while polling provider " + get(i).getName() + " for version", e);
            }
        }
        return null;
    }

    public RecommendationStrategies getStrategy() {
        return strategy;
    }

    public void setStrategy(RecommendationStrategies strategy) {
        this.strategy = strategy;
    }

    public Boolean isStrictMode() {
        return strictMode;
    }

    public void setStrictMode(Boolean strict) {
        strictMode = strict;
    }
    
    public void excludeConfigurations(String ... names) {
        excludedConfigurations.addAll(Arrays.asList(names));
    }

    public Set<String> getExcludedConfigurations() {
        return excludedConfigurations;
    }

    public Set<String> getReasons() {
        return reasons;
    }

    private static void ensureCoreBomSupportNotEnabled(String feature) {
        if(CORE_BOM_SUPPORT_ENABLED) {
            throw new GradleException("dependencyRecommender." + feature + " is not available with 'systemProp.nebula.features.coreBomSupport=true'");
        }
    }
}

1	/*
2	* Copyright 2014-2017 Netflix, Inc.
3	*
4	* Licensed under the Apache License, Version 2.0 (the "License");
5	* you may not use this file except in compliance with the License.
6	* You may obtain a copy of the License at
7	*
8	* http://www.apache.org/licenses/LICENSE-2.0
9	*
10	* Unless required by applicable law or agreed to in writing, software
11	* distributed under the License is distributed on an "AS IS" BASIS,
12	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13	* See the License for the specific language governing permissions and
14	* limitations under the License.
15	*/
16	package netflix.nebula.dependency.recommender.provider;
17
18	import groovy.lang.Closure;
19	import netflix.nebula.dependency.recommender.DependencyRecommendationsPlugin;
20	import netflix.nebula.dependency.recommender.RecommendationStrategies;
21	import org.gradle.api.Action;
22	import org.gradle.api.GradleException;
23	import org.gradle.api.Namer;
24	import org.gradle.api.Project;
25	import org.gradle.api.internal.ConfigureByMapAction;
26	import org.gradle.api.internal.DefaultNamedDomainObjectList;
27	import org.gradle.util.ConfigureUtil;
28
29	import java.util.Arrays;
30	import java.util.HashMap;
31	import java.util.HashSet;
32	import java.util.Map;
33	import java.util.Set;
34
35	import static netflix.nebula.dependency.recommender.DependencyRecommendationsPlugin.CORE_BOM_SUPPORT_ENABLED;
36
37	public class RecommendationProviderContainer extends DefaultNamedDomainObjectList<RecommendationProvider> {
38
39	private Project project;
40	private RecommendationStrategies strategy = RecommendationStrategies.ConflictResolved;	1✔
41	private MavenBomRecommendationProvider mavenBomProvider;
42	private Boolean strictMode = false;	1✔
43	private Set<String> excludedConfigurations = new HashSet<>();	1✔
44	private Set<String> reasons = new HashSet<>();	1✔
45
46	// Make strategies available without import
47	public static final RecommendationStrategies OverrideTransitives = RecommendationStrategies.OverrideTransitives;	1✔
48	public static final RecommendationStrategies ConflictResolved = RecommendationStrategies.ConflictResolved;	1✔
49
50	private final Action<? super RecommendationProvider> addLastAction = new Action<RecommendationProvider>() {	1✔
51	public void execute(RecommendationProvider r) {
52	RecommendationProviderContainer.super.add(r);	1✔
53	}	1✔
54	};
55
56	public RecommendationProviderContainer(Project project) {
57	super(RecommendationProvider.class, null, new RecommendationProviderNamer());	1✔
58	this.project = project;	1✔
59	this.mavenBomProvider = new MavenBomRecommendationProvider(this.project, DependencyRecommendationsPlugin.NEBULA_RECOMMENDER_BOM, this.reasons);	1✔
60	this.add(this.mavenBomProvider);	1✔
61	}	1✔
62
63	private static class RecommendationProviderNamer implements Namer<RecommendationProvider> {
64	public String determineName(RecommendationProvider r) {
65	return r.getName();	1✔
66	}
67	}
68
69	public <T extends RecommendationProvider> T addProvider(T provider, Action<? super T> configureAction) {
70	configureAction.execute(provider);	1✔
71	assertCanAdd(provider.getName());	1✔
72	addLastAction.execute(provider);	1✔
73	return provider;	1✔
74	}
75
76	public <T extends RecommendationProvider> T addFirst(T provider) {
77	remove(provider);	1✔
78	super.add(0, provider);	1✔
79	return provider;	1✔
80	}
81
82	public PropertyFileRecommendationProvider propertiesFile(Map<String, ?> args) {
83	ensureCoreBomSupportNotEnabled("propertiesFile");	1✔
84	String message = "nebula.dependency-recommender uses a properties file: " + args.get("file");	1✔
85	reasons.add(message);	1✔
86	Map<String, Object> modifiedArgs = new HashMap<String, Object>(args);	1✔
87	return addProvider(new PropertyFileRecommendationProvider(project), new ConfigureByMapAction<PropertyFileRecommendationProvider>(modifiedArgs));	1✔
88	}
89
90	public PropertyFileRecommendationProvider propertiesFile(Closure closure) {
91	ensureCoreBomSupportNotEnabled("propertiesFile");	×
92	String message = "nebula.dependency-recommender uses a properties file";	×
93	reasons.add(message);	×
94	return addProvider(new PropertyFileRecommendationProvider(project), ConfigureUtil.<PropertyFileRecommendationProvider>configureUsing(closure));	×
95	}
96
97	public MavenBomRecommendationProvider mavenBom(Map<String, ?> args) {
98	Object dependencyNotation = args.get("module");	1✔
99	if(dependencyNotation == null) {	1✔
100	throw new IllegalArgumentException("Module may not be null");	×
101	}
102
103	if (!CORE_BOM_SUPPORT_ENABLED) {	1✔
104	if (Map.class.isAssignableFrom(dependencyNotation.getClass())) {	1✔
105	((Map) dependencyNotation).put("ext", "pom");	×
106	} else if (!dependencyNotation.toString().endsWith("@pom")) {	1✔
107	dependencyNotation = dependencyNotation.toString() + "@pom";	1✔
108	}
109	}
110	project.getDependencies().add(DependencyRecommendationsPlugin.NEBULA_RECOMMENDER_BOM, dependencyNotation);	1✔
111
112	return mavenBomProvider;	1✔
113	}
114
115	public IvyRecommendationProvider ivyXml(Map<String, ?> args) {
116	ensureCoreBomSupportNotEnabled("ivyXml");	×
117	String message = "nebula.dependency-recommender uses a ivyXml: " + args.get("module");	×
118	reasons.add(message);	×
119	Map<String, Object> modifiedArgs = new HashMap<String, Object>(args);	×
120	return addProvider(new IvyRecommendationProvider(project), new ConfigureByMapAction<IvyRecommendationProvider>(modifiedArgs));	×
121	}
122
123	public IvyRecommendationProvider ivyXml(Closure closure) {
124	ensureCoreBomSupportNotEnabled("ivyXml");	×
125	String message = "nebula.dependency-recommender uses a ivyXml";	×
126	reasons.add(message);	×
127	return addProvider(new IvyRecommendationProvider(project), ConfigureUtil.<IvyRecommendationProvider>configureUsing(closure));	×
128	}
129
130	public DependencyLockProvider dependencyLock(Map<String, ?> args) {
131	ensureCoreBomSupportNotEnabled("dependencyLock");	×
132	String message = "nebula.dependency-recommender uses a dependency lock: " + args.get("module");	×
133	reasons.add(message);	×
134	Map<String, Object> modifiedArgs = new HashMap<String, Object>(args);	×
135	return addProvider(new DependencyLockProvider(project), new ConfigureByMapAction<DependencyLockProvider>(modifiedArgs));	×
136	}
137
138	public DependencyLockProvider dependencyLock(Closure closure) {
139	ensureCoreBomSupportNotEnabled("dependencyLock");	×
140	String message = "nebula.dependency-recommender uses a dependency lock for recommendations";	×
141	reasons.add(message);	×
142	return addProvider(new DependencyLockProvider(project), ConfigureUtil.<DependencyLockProvider>configureUsing(closure));	×
143	}
144
145	public MapRecommendationProvider map(Map<String, ?> args) {
146	ensureCoreBomSupportNotEnabled("map");	1✔
147	String message = "nebula.dependency-recommender uses a provided map for recommendations";	1✔
148	reasons.add(message);	1✔
149	Map<String, Object> modifiedArgs = new HashMap<String, Object>(args);	1✔
150	return addProvider(new MapRecommendationProvider(), new ConfigureByMapAction<MapRecommendationProvider>(modifiedArgs));	1✔
151	}
152
153	public MapRecommendationProvider map(Closure closure) {
154	ensureCoreBomSupportNotEnabled("map");	×
155	String message = "nebula.dependency-recommender uses a provided map for recommendations";	×
156	reasons.add(message);	×
157	return addProvider(new MapRecommendationProvider(), ConfigureUtil.<MapRecommendationProvider>configureUsing(closure));	×
158	}
159
160	public CustomRecommendationProvider addProvider(Closure closure) {
161	ensureCoreBomSupportNotEnabled("addProvider");	×
162	String message = "nebula.dependency-recommender uses a CustomRecommendationProvider";	×
163	reasons.add(message);	×
164	return addProvider(new CustomRecommendationProvider(closure), new Action<CustomRecommendationProvider>() {	×
165	@Override
166	public void execute(CustomRecommendationProvider customRecommendationProvider) {
167	}	×
168	});
169	}
170
171	public MavenBomRecommendationProvider getMavenBomProvider() {
172	return mavenBomProvider;	×
173	}
174
175	public String getRecommendedVersion(String group, String name) {
176	// providers are queried in LIFO order
177	for (int i = size()-1; i >= 0; i--) {	1✔
178	try {
179	String version = get(i).getVersion(group, name);	1✔
180	if (version != null) {	1✔
181	return version;	1✔
182	}
183	} catch(Exception e) {	×
184	project.getLogger().error("Exception while polling provider " + get(i).getName() + " for version", e);	×
185	}	1✔
186	}
187	return null;	1✔
188	}
189
190	public RecommendationStrategies getStrategy() {
191	return strategy;	1✔
192	}
193
194	public void setStrategy(RecommendationStrategies strategy) {
195	this.strategy = strategy;	1✔
196	}	1✔
197
198	public Boolean isStrictMode() {
199	return strictMode;	1✔
200	}
201
202	public void setStrictMode(Boolean strict) {
203	strictMode = strict;	1✔
204	}	1✔
205
206	public void excludeConfigurations(String ... names) {
207	excludedConfigurations.addAll(Arrays.asList(names));	1✔
208	}	1✔
209
210	public Set<String> getExcludedConfigurations() {
211	return excludedConfigurations;	1✔
212	}
213
214	public Set<String> getReasons() {
215	return reasons;	1✔
216	}
217
218	private static void ensureCoreBomSupportNotEnabled(String feature) {
219	if(CORE_BOM_SUPPORT_ENABLED) {	1✔
220	throw new GradleException("dependencyRecommender." + feature + " is not available with 'systemProp.nebula.features.coreBomSupport=true'");	×
221	}
222	}	1✔
223	}

nebula-plugins / nebula-dependency-recommender-plugin / 320

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous