extractArtifactVersionDependencyVersion(
84 | DependencyVersion other) {
85 | ArtifactVersionDependencyVersion artifactVersion = null;
86 | if (other instanceof ArtifactVersionDependencyVersion) {
87 | artifactVersion = (ArtifactVersionDependencyVersion) other;
88 | }
89 | return Optional.ofNullable(artifactVersion);
90 | }
91 |
92 | static ArtifactVersionDependencyVersion parse(String version) {
93 | ArtifactVersion artifactVersion = new DefaultArtifactVersion(version);
94 | if (artifactVersion.getQualifier() != null && artifactVersion.getQualifier().equals(version)) {
95 | return null;
96 | }
97 | return new ArtifactVersionDependencyVersion(artifactVersion);
98 | }
99 |
100 | }
101 |
--------------------------------------------------------------------------------
/src/test/resources/artifacts/org/quartz-scheduler/quartz/index.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 | Central Repository: org/quartz-scheduler/quartz
6 |
7 |
12 |
13 |
14 |
15 |
16 | org/quartz-scheduler/quartz
17 |
18 |
19 |
20 |
21 | ../
22 | 1.7.2/ 2010-02-10 14:53 -
23 | 1.7.3/ 2010-02-24 18:47 -
24 | 1.8.0/ 2010-04-23 04:45 -
25 | 1.8.1/ 2010-06-11 21:10 -
26 | 1.8.2/ 2010-06-17 23:56 -
27 | 1.8.3/ 2010-06-22 21:09 -
28 | 1.8.4/ 2010-07-19 23:03 -
29 | 1.8.5/ 2011-04-14 03:30 -
30 | 1.8.6/ 2012-01-12 21:43 -
31 | 2.0.0/ 2011-03-28 20:33 -
32 | 2.0.1/ 2011-04-14 03:39 -
33 | 2.0.2/ 2011-07-07 18:47 -
34 | 2.1.0/ 2011-09-22 21:47 -
35 | 2.1.1/ 2011-11-14 20:21 -
36 | 2.1.2/ 2011-12-20 13:56 -
37 | 2.1.3/ 2012-01-30 19:30 -
38 | 2.1.4/ 2012-04-17 19:22 -
39 | 2.1.5/ 2012-04-27 14:50 -
40 | 2.1.6/ 2013-02-22 21:15 -
41 | 2.1.7/ 2013-03-05 15:24 -
42 | 2.2.0/ 2013-06-29 21:06 -
43 | 2.2.1/ 2013-09-25 18:50 -
44 | 2.2.2/ 2015-10-12 11:52 -
45 | 2.2.3/ 2016-04-18 18:27 -
46 | 2.3.0/ 2017-04-19 19:41 -
47 | maven-metadata.xml 2017-04-19 20:16 1077
48 | maven-metadata.xml.md5 2017-04-19 20:16 32
49 | maven-metadata.xml.sha1 2017-04-19 20:16 40
50 |
51 |
52 |
53 |
54 |
55 |
--------------------------------------------------------------------------------
/src/test/resources/artifacts/org/quartz-scheduler/quartz-parent/index.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 | Central Repository: org/quartz-scheduler/quartz-parent
6 |
7 |
12 |
13 |
14 |
15 |
16 | org/quartz-scheduler/quartz-parent
17 |
18 |
19 |
20 |
21 | ../
22 | 1.7.0/ - -
23 | 1.7.2/ 2010-02-10 14:52 -
24 | 1.7.3/ 2010-02-24 18:46 -
25 | 1.8.0/ 2010-04-23 04:45 -
26 | 1.8.1/ 2010-06-11 21:09 -
27 | 1.8.2/ 2010-06-17 23:55 -
28 | 1.8.3/ 2010-06-22 21:09 -
29 | 1.8.4/ 2010-07-19 23:01 -
30 | 1.8.5/ 2011-04-14 03:30 -
31 | 1.8.6/ 2012-01-12 21:43 -
32 | 2.0.0/ 2011-03-28 20:32 -
33 | 2.0.1/ 2011-04-14 03:38 -
34 | 2.0.2/ 2011-07-07 18:45 -
35 | 2.1.0/ 2011-09-22 21:46 -
36 | 2.1.1/ 2011-11-14 20:21 -
37 | 2.1.2/ 2011-12-20 13:53 -
38 | 2.1.3/ 2012-01-30 19:27 -
39 | 2.1.4/ 2012-04-17 19:21 -
40 | 2.1.5/ 2012-04-27 14:50 -
41 | 2.1.6/ 2013-02-22 21:12 -
42 | 2.1.7/ 2013-03-05 15:22 -
43 | 2.2.0/ 2013-06-29 21:02 -
44 | 2.2.1/ 2013-09-25 18:46 -
45 | 2.2.2/ 2015-10-12 11:51 -
46 | 2.2.3/ 2016-04-18 18:25 -
47 | 2.3.0/ 2017-04-19 19:40 -
48 | maven-metadata.xml 2017-04-19 20:16 1084
49 | maven-metadata.xml.md5 2017-04-19 20:16 32
50 | maven-metadata.xml.sha1 2017-04-19 20:16 40
51 |
52 |
53 |
54 |
55 |
56 |
--------------------------------------------------------------------------------
/src/test/java/io/spring/bomr/upgrade/MavenMetadataVersionResolverTests.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2017-2019 the original author or authors.
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 | * https://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 |
17 | package io.spring.bomr.upgrade;
18 |
19 | import java.io.File;
20 | import java.util.Arrays;
21 | import java.util.Set;
22 | import java.util.stream.Collectors;
23 |
24 | import io.spring.bomr.upgrade.version.DependencyVersion;
25 | import org.junit.Test;
26 |
27 | import org.springframework.core.io.FileSystemResource;
28 | import org.springframework.http.HttpMethod;
29 | import org.springframework.http.MediaType;
30 | import org.springframework.test.web.client.MockRestServiceServer;
31 | import org.springframework.test.web.client.match.MockRestRequestMatchers;
32 | import org.springframework.test.web.client.response.MockRestResponseCreators;
33 | import org.springframework.web.client.RestTemplate;
34 |
35 | import static org.assertj.core.api.Assertions.assertThat;
36 |
37 | /**
38 | * Tests for {@link MavenMetadataVersionResolver}.
39 | *
40 | * @author Andy Wilkinson
41 | */
42 | public class MavenMetadataVersionResolverTests {
43 |
44 | @Test
45 | public void versionsAreResolvedFromMavenMetadata() {
46 | RestTemplate rest = new RestTemplate();
47 | MockRestServiceServer server = MockRestServiceServer.bindTo(rest).build();
48 | server.expect(MockRestRequestMatchers
49 | .requestTo("https://repo.example.com/maven2/org/springframework/spring-core/maven-metadata.xml"))
50 | .andExpect(MockRestRequestMatchers.method(HttpMethod.GET))
51 | .andRespond(MockRestResponseCreators.withSuccess(
52 | new FileSystemResource(new File("src/test/resources/spring-core-maven-metadata.xml")),
53 | MediaType.TEXT_XML));
54 | Set versions = new MavenMetadataVersionResolver(rest,
55 | Arrays.asList("https://repo.example.com/maven2/"))
56 | .resolveVersions(new Module("org.springframework", "spring-core"));
57 | assertThat(versions.stream().map(DependencyVersion::toString).collect(Collectors.toList())).containsExactly(
58 | "4.3.0.RELEASE", "4.3.1.RELEASE", "4.3.2.RELEASE", "4.3.3.RELEASE", "4.3.4.RELEASE", "4.3.5.RELEASE",
59 | "4.3.6.RELEASE", "4.3.7.RELEASE", "4.3.8.RELEASE", "4.3.9.RELEASE", "4.3.10.RELEASE", "4.3.11.RELEASE",
60 | "5.0.0.RELEASE");
61 | }
62 |
63 | @Test
64 | public void versionsFromMultipleRepositoriesAreCombined() {
65 | RestTemplate rest = new RestTemplate();
66 | MockRestServiceServer server = MockRestServiceServer.bindTo(rest).build();
67 | server.expect(
68 | MockRestRequestMatchers.requestTo("https://repo1.example.com/com/example/core/maven-metadata.xml"))
69 | .andExpect(MockRestRequestMatchers.method(HttpMethod.GET))
70 | .andRespond(MockRestResponseCreators.withSuccess(
71 | new FileSystemResource(new File("src/test/resources/repo1-maven-metadata.xml")),
72 | MediaType.TEXT_XML));
73 | server.expect(
74 | MockRestRequestMatchers.requestTo("https://repo2.example.com/com/example/core/maven-metadata.xml"))
75 | .andExpect(MockRestRequestMatchers.method(HttpMethod.GET))
76 | .andRespond(MockRestResponseCreators.withSuccess(
77 | new FileSystemResource(new File("src/test/resources/repo2-maven-metadata.xml")),
78 | MediaType.TEXT_XML));
79 | Set versions = new MavenMetadataVersionResolver(rest,
80 | Arrays.asList("https://repo1.example.com", "https://repo2.example.com"))
81 | .resolveVersions(new Module("com.example", "core"));
82 | assertThat(versions.stream().map(DependencyVersion::toString).collect(Collectors.toList()))
83 | .containsExactly("1.0.0.RELEASE", "1.1.0.RELEASE");
84 | }
85 |
86 | }
87 |
--------------------------------------------------------------------------------
/src/main/java/io/spring/bomr/upgrade/version/ReleaseTrainDependencyVersion.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2017-2021 the original author or authors.
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 | * https://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 |
17 | package io.spring.bomr.upgrade.version;
18 |
19 | import java.util.regex.Matcher;
20 | import java.util.regex.Pattern;
21 |
22 | import org.springframework.util.StringUtils;
23 |
24 | /**
25 | * A {@link DependencyVersion} for a release train such as Spring Data.
26 | *
27 | * @author Andy Wilkinson
28 | */
29 | final class ReleaseTrainDependencyVersion implements DependencyVersion {
30 |
31 | private static final Pattern VERSION_PATTERN = Pattern.compile("([A-Z][a-z]+)-([A-Z]+)([0-9]*)");
32 |
33 | private final String releaseTrain;
34 |
35 | private final String type;
36 |
37 | private final int version;
38 |
39 | private final String original;
40 |
41 | private ReleaseTrainDependencyVersion(String releaseTrain, String type, int version, String original) {
42 | this.releaseTrain = releaseTrain;
43 | this.type = type;
44 | this.version = version;
45 | this.original = original;
46 | }
47 |
48 | @Override
49 | public int compareTo(DependencyVersion other) {
50 | if (!(other instanceof ReleaseTrainDependencyVersion)) {
51 | return -1;
52 | }
53 | ReleaseTrainDependencyVersion otherReleaseTrain = (ReleaseTrainDependencyVersion) other;
54 | int comparison = this.releaseTrain.compareTo(otherReleaseTrain.releaseTrain);
55 | if (comparison != 0) {
56 | return comparison;
57 | }
58 | comparison = this.type.compareTo(otherReleaseTrain.type);
59 | if (comparison != 0) {
60 | return comparison;
61 | }
62 | return Integer.compare(this.version, otherReleaseTrain.version);
63 | }
64 |
65 | @Override
66 | public boolean isNewerThan(DependencyVersion other) {
67 | if (!(other instanceof ReleaseTrainDependencyVersion)) {
68 | return true;
69 | }
70 | ReleaseTrainDependencyVersion otherReleaseTrain = (ReleaseTrainDependencyVersion) other;
71 | return otherReleaseTrain.compareTo(this) < 0;
72 | }
73 |
74 | @Override
75 | public boolean isSameMajorAndNewerThan(DependencyVersion other) {
76 | return isNewerThan(other);
77 | }
78 |
79 | @Override
80 | public boolean isSameMinorAndNewerThan(DependencyVersion other) {
81 | if (!(other instanceof ReleaseTrainDependencyVersion)) {
82 | return true;
83 | }
84 | ReleaseTrainDependencyVersion otherReleaseTrain = (ReleaseTrainDependencyVersion) other;
85 | return otherReleaseTrain.releaseTrain.equals(this.releaseTrain) && isNewerThan(other);
86 | }
87 |
88 | @Override
89 | public boolean equals(Object obj) {
90 | if (this == obj) {
91 | return true;
92 | }
93 | if (obj == null) {
94 | return false;
95 | }
96 | if (getClass() != obj.getClass()) {
97 | return false;
98 | }
99 | ReleaseTrainDependencyVersion other = (ReleaseTrainDependencyVersion) obj;
100 | if (!this.original.equals(other.original)) {
101 | return false;
102 | }
103 | return true;
104 | }
105 |
106 | @Override
107 | public int hashCode() {
108 | return this.original.hashCode();
109 | }
110 |
111 | @Override
112 | public String toString() {
113 | return this.original;
114 | }
115 |
116 | static ReleaseTrainDependencyVersion parse(String input) {
117 | Matcher matcher = VERSION_PATTERN.matcher(input);
118 | if (!matcher.matches()) {
119 | return null;
120 | }
121 | return new ReleaseTrainDependencyVersion(matcher.group(1), matcher.group(2),
122 | (StringUtils.hasLength(matcher.group(3))) ? Integer.parseInt(matcher.group(3)) : 0, input);
123 | }
124 |
125 | }
126 |
--------------------------------------------------------------------------------
/src/test/java/io/spring/bomr/upgrade/version/ReleaseTrainDependencyVersionTests.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2017-2021 the original author or authors.
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 | * https://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 |
17 | package io.spring.bomr.upgrade.version;
18 |
19 | import org.junit.Test;
20 |
21 | import static org.assertj.core.api.Assertions.assertThat;
22 |
23 | /**
24 | * Tests for {@link ReleaseTrainDependencyVersion}.
25 | *
26 | * @author Andy Wilkinson
27 | */
28 | public class ReleaseTrainDependencyVersionTests {
29 |
30 | @Test
31 | public void parsingOfANonReleaseTrainVersionReturnsNull() {
32 | assertThat(version("5.1.4.RELEASE")).isNull();
33 | }
34 |
35 | @Test
36 | public void parsingOfAReleaseTrainVersionReturnsVersion() {
37 | assertThat(version("Lovelace-SR3")).isNotNull();
38 | }
39 |
40 | @Test
41 | public void isNewerThanWhenReleaseTrainIsNewerShouldReturnTrue() {
42 | assertThat(version("Lovelace-RELEASE").isNewerThan(version("Kay-SR5"))).isTrue();
43 | }
44 |
45 | @Test
46 | public void isNewerThanWhenVersionIsNewerShouldReturnTrue() {
47 | assertThat(version("Kay-SR10").isNewerThan(version("Kay-SR5"))).isTrue();
48 | }
49 |
50 | @Test
51 | public void isNewerThanWhenVersionIsOlderShouldReturnFalse() {
52 | assertThat(version("Kay-RELEASE").isNewerThan(version("Kay-SR5"))).isFalse();
53 | }
54 |
55 | @Test
56 | public void isNewerThanWhenReleaseTrainIsOlderShouldReturnFalse() {
57 | assertThat(version("Ingalls-RELEASE").isNewerThan(version("Kay-SR5"))).isFalse();
58 | }
59 |
60 | @Test
61 | public void isSameMajorAndNewerWhenWhenReleaseTrainIsNewerShouldReturnTrue() {
62 | assertThat(version("Lovelace-RELEASE").isSameMajorAndNewerThan(version("Kay-SR5"))).isTrue();
63 | }
64 |
65 | @Test
66 | public void isSameMajorAndNewerThanWhenReleaseTrainIsOlderShouldReturnFalse() {
67 | assertThat(version("Ingalls-RELEASE").isSameMajorAndNewerThan(version("Kay-SR5"))).isFalse();
68 | }
69 |
70 | @Test
71 | public void isSameMajorAndNewerThanWhenVersionIsNewerShouldReturnTrue() {
72 | assertThat(version("Kay-SR6").isSameMajorAndNewerThan(version("Kay-SR5"))).isTrue();
73 | }
74 |
75 | @Test
76 | public void isSameMinorAndNewerThanWhenReleaseTrainIsNewerShouldReturnFalse() {
77 | assertThat(version("Lovelace-RELEASE").isSameMinorAndNewerThan(version("Kay-SR5"))).isFalse();
78 | }
79 |
80 | @Test
81 | public void isSameMinorAndNewerThanWhenReleaseTrainIsTheSameAndVersionIsNewerShouldReturnTrue() {
82 | assertThat(version("Kay-SR6").isSameMinorAndNewerThan(version("Kay-SR5"))).isTrue();
83 | }
84 |
85 | @Test
86 | public void isSameMinorAndNewerThanWhenReleaseTrainAndVersionAreTheSameShouldReturnFalse() {
87 | assertThat(version("Kay-SR6").isSameMinorAndNewerThan(version("Kay-SR6"))).isFalse();
88 | }
89 |
90 | @Test
91 | public void isSameMinorAndNewerThanWhenReleaseTrainIsTheSameAndVersionIsOlderShouldReturnFalse() {
92 | assertThat(version("Kay-SR6").isSameMinorAndNewerThan(version("Kay-SR7"))).isFalse();
93 | }
94 |
95 | @Test
96 | public void whenComparedWithADifferentDependencyVersionTypeThenTheResultsAreNonZero() {
97 | ReleaseTrainDependencyVersion dysprosium = ReleaseTrainDependencyVersion.parse("Dysprosium-SR16");
98 | ArtifactVersionDependencyVersion twentyTwenty = ArtifactVersionDependencyVersion.parse("2020.0.0");
99 | assertThat(dysprosium.compareTo(twentyTwenty)).isLessThan(0);
100 | assertThat(twentyTwenty.compareTo(dysprosium)).isGreaterThan(0);
101 | }
102 |
103 | private static ReleaseTrainDependencyVersion version(String input) {
104 | return ReleaseTrainDependencyVersion.parse(input);
105 | }
106 |
107 | }
108 |
--------------------------------------------------------------------------------
/src/test/java/io/spring/bomr/upgrade/version/ArtifactVersionDependencyVersionTests.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2017-2019 the original author or authors.
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 | * https://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 |
17 | package io.spring.bomr.upgrade.version;
18 |
19 | import org.junit.Test;
20 |
21 | import static org.assertj.core.api.Assertions.assertThat;
22 |
23 | /**
24 | * Tests for {@link ArtifactVersionDependencyVersion}.
25 | *
26 | * @author Andy Wilkinson
27 | */
28 | public class ArtifactVersionDependencyVersionTests {
29 |
30 | @Test
31 | public void parseWhenVersionIsNotAMavenVersionShouldReturnNull() {
32 | assertThat(version("1.2.3.1")).isNull();
33 | }
34 |
35 | @Test
36 | public void parseWhenVersionIsAMavenVersionShouldReturnAVersion() {
37 | assertThat(version("1.2.3")).isNotNull();
38 | }
39 |
40 | @Test
41 | public void isNewerThanWhenInputIsOlderMajorShouldReturnTrue() {
42 | assertThat(version("2.1.2").isNewerThan(version("1.9.0"))).isTrue();
43 | }
44 |
45 | @Test
46 | public void isNewerThanWhenInputIsOlderMinorShouldReturnTrue() {
47 | assertThat(version("2.1.2").isNewerThan(version("2.0.2"))).isTrue();
48 | }
49 |
50 | @Test
51 | public void isNewerThanWhenInputIsOlderPatchShouldReturnTrue() {
52 | assertThat(version("2.1.2").isNewerThan(version("2.1.1"))).isTrue();
53 | }
54 |
55 | @Test
56 | public void isNewerThanWhenInputIsNewerMajorShouldReturnFalse() {
57 | assertThat(version("2.1.2").isNewerThan(version("3.2.1"))).isFalse();
58 | }
59 |
60 | @Test
61 | public void isSameMajorAndNewerThanWhenMinorIsOlderShouldReturnTrue() {
62 | assertThat(version("1.10.2").isSameMajorAndNewerThan(version("1.9.0"))).isTrue();
63 | }
64 |
65 | @Test
66 | public void isSameMajorAndNewerThanWhenMajorIsOlderShouldReturnFalse() {
67 | assertThat(version("2.0.2").isSameMajorAndNewerThan(version("1.9.0"))).isFalse();
68 | }
69 |
70 | @Test
71 | public void isSameMajorAndNewerThanWhenPatchIsNewerShouldReturnTrue() {
72 | assertThat(version("2.1.2").isSameMajorAndNewerThan(version("2.1.1"))).isTrue();
73 | }
74 |
75 | @Test
76 | public void isSameMajorAndNewerThanWhenMinorIsNewerShouldReturnFalse() {
77 | assertThat(version("2.1.2").isSameMajorAndNewerThan(version("2.2.1"))).isFalse();
78 | }
79 |
80 | @Test
81 | public void isSameMajorAndNewerThanWhenMajorIsNewerShouldReturnFalse() {
82 | assertThat(version("2.1.2").isSameMajorAndNewerThan(version("3.0.1"))).isFalse();
83 | }
84 |
85 | @Test
86 | public void isSameMinorAndNewerThanWhenPatchIsOlderShouldReturnTrue() {
87 | assertThat(version("1.10.2").isSameMinorAndNewerThan(version("1.10.1"))).isTrue();
88 | }
89 |
90 | @Test
91 | public void isSameMinorAndNewerThanWhenMinorIsOlderShouldReturnFalse() {
92 | assertThat(version("2.1.2").isSameMinorAndNewerThan(version("2.0.1"))).isFalse();
93 | }
94 |
95 | @Test
96 | public void isSameMinorAndNewerThanWhenVersionsAreTheSameShouldReturnFalse() {
97 | assertThat(version("2.1.2").isSameMinorAndNewerThan(version("2.1.2"))).isFalse();
98 | }
99 |
100 | @Test
101 | public void isSameMinorAndNewerThanWhenPatchIsNewerShouldReturnFalse() {
102 | assertThat(version("2.1.2").isSameMinorAndNewerThan(version("2.1.3"))).isFalse();
103 | }
104 |
105 | @Test
106 | public void isSameMinorAndNewerThanWhenMinorIsNewerShouldReturnFalse() {
107 | assertThat(version("2.1.2").isSameMinorAndNewerThan(version("2.0.1"))).isFalse();
108 | }
109 |
110 | @Test
111 | public void isSameMinorAndNewerThanWhenMajorIsNewerShouldReturnFalse() {
112 | assertThat(version("3.1.2").isSameMinorAndNewerThan(version("2.0.1"))).isFalse();
113 | }
114 |
115 | private ArtifactVersionDependencyVersion version(String version) {
116 | return ArtifactVersionDependencyVersion.parse(version);
117 | }
118 |
119 | }
120 |
--------------------------------------------------------------------------------
/src/main/java/io/spring/bomr/verify/BomVerifier.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2017-2019 the original author or authors.
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 | * https://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 |
17 | package io.spring.bomr.verify;
18 |
19 | import java.io.File;
20 | import java.io.FileWriter;
21 | import java.net.URI;
22 | import java.util.ArrayList;
23 | import java.util.HashMap;
24 | import java.util.List;
25 | import java.util.Map;
26 | import java.util.Properties;
27 | import java.util.Set;
28 | import java.util.stream.Collectors;
29 |
30 | import com.samskivert.mustache.Mustache;
31 | import com.samskivert.mustache.Mustache.Compiler;
32 | import com.samskivert.mustache.Mustache.TemplateLoader;
33 | import com.samskivert.mustache.Template;
34 | import io.spring.bomr.verify.MavenInvoker.MavenInvocationFailedException;
35 |
36 | import org.springframework.util.StringUtils;
37 |
38 | /**
39 | * Verifies a Maven bom by checking that all of its managed dependencies can be resolved.
40 | *
41 | * @author Andy Wilkinson
42 | */
43 | class BomVerifier {
44 |
45 | private final MavenInvoker mavenInvoker;
46 |
47 | private final Compiler compiler;
48 |
49 | private final TemplateLoader templateLoader;
50 |
51 | BomVerifier(MavenInvoker mavenInvoker, Compiler compiler, TemplateLoader templateLoader) {
52 | this.mavenInvoker = mavenInvoker;
53 | this.compiler = compiler;
54 | this.templateLoader = templateLoader;
55 | }
56 |
57 | void verify(File bom, Set ignoredDependencies, Set repositoryUris) {
58 | VerifiableBom verifiableBom = new VerifiableBom(this.mavenInvoker, bom);
59 | List dependenciesToVerify = verifiableBom.getManagedDependencies().stream()
60 | .filter((dependency) -> !ignoredDependencies
61 | .contains(dependency.getGroupId() + ":" + dependency.getArtifactId()))
62 | .collect(Collectors.toList());
63 | File dependenciesPom = createDependenciesPom(bom, verifiableBom, dependenciesToVerify,
64 | repositoryUris.stream().map(Repository::new).collect(Collectors.toList()));
65 | System.out.print("Verifying " + dependenciesToVerify.size() + " dependencies...");
66 | try {
67 | this.mavenInvoker.invoke(dependenciesPom, new Properties(), "dependency:list");
68 | System.out.println(" Done.");
69 | }
70 | catch (MavenInvocationFailedException ex) {
71 | System.err.println();
72 | System.err.println("Dependency resolution failed:");
73 | System.err.println();
74 | ex.getOutputLines().forEach(System.err::println);
75 | }
76 | }
77 |
78 | private File createDependenciesPom(File bomFile, VerifiableBom bom, List dependenciesToVerify,
79 | List additionalRepositories) {
80 | try {
81 | Template template = this.compiler.compile(this.templateLoader.getTemplate("bom-dependencies"));
82 | Map context = new HashMap<>();
83 | context.put("dependencies", dependenciesToVerify);
84 | List repositories = new ArrayList<>(bom.getRepositories());
85 | repositories.addAll(additionalRepositories);
86 | context.put("repositories", repositories);
87 | context.put("parentGroupId", bom.getGroupId());
88 | context.put("parentArtifactId", bom.getArtifactId());
89 | context.put("parentVersion", bom.getVersion());
90 | context.put("parentRelativePath", bomFile.getAbsolutePath());
91 | context.put("classifierIfAvailable", (Mustache.Lambda) (frag, out) -> {
92 | String classifier = frag.execute();
93 | if (StringUtils.hasText(classifier)) {
94 | out.append("");
95 | out.append(classifier);
96 | out.append("\n");
97 | }
98 | });
99 | File dependenciesPom = File.createTempFile("dependencies-", ".pom");
100 | try (FileWriter writer = new FileWriter(dependenciesPom)) {
101 | template.execute(context, writer);
102 | }
103 | return dependenciesPom;
104 | }
105 | catch (Exception ex) {
106 | throw new RuntimeException(ex);
107 | }
108 | }
109 |
110 | }
111 |
--------------------------------------------------------------------------------
/src/test/resources/artifacts/org/infinispan/page6.json:
--------------------------------------------------------------------------------
1 | {
2 | "response": {
3 | "docs": [
4 | {
5 | "a": "infinispan-server-core",
6 | "ec": [
7 | "-sources.jar",
8 | "-test-sources.jar",
9 | "-tests.jar",
10 | ".jar",
11 | ".pom"
12 | ],
13 | "g": "org.infinispan",
14 | "id": "org.infinispan:infinispan-server-core:9.4.15.Final",
15 | "p": "bundle",
16 | "tags": [
17 | "infinispan",
18 | "server",
19 | "core",
20 | "components"
21 | ],
22 | "timestamp": 1560795545000,
23 | "v": "9.4.15.Final"
24 | },
25 | {
26 | "a": "infinispan-spring5-common",
27 | "ec": [
28 | "-sources.jar",
29 | "-test-sources.jar",
30 | ".jar",
31 | "-tests.jar",
32 | ".pom"
33 | ],
34 | "g": "org.infinispan",
35 | "id": "org.infinispan:infinispan-spring5-common:9.4.15.Final",
36 | "p": "jar",
37 | "tags": [
38 | "distributed",
39 | "used",
40 | "same",
41 | "springframework",
42 | "namespace",
43 | "accesses",
44 | "over",
45 | "primary",
46 | "features",
47 | "facilitating",
48 | "factorybeans",
49 | "central",
50 | "support",
51 | "defined",
52 | "offers",
53 | "definitions",
54 | "project",
55 | "powered",
56 | "infinispan",
57 | "abstraction",
58 | "backed",
59 | "components",
60 | "outside",
61 | "creation",
62 | "remotecachemanager",
63 | "cachemanager",
64 | "remotely",
65 | "from",
66 | "running",
67 | "spring",
68 | "embeddedcachemanager",
69 | "network",
70 | "shortcut",
71 | "allowing",
72 | "integration",
73 | "performance",
74 | "above",
75 | "various",
76 | "colocated",
77 | "jndi",
78 | "retrieved",
79 | "caching",
80 | "classes",
81 | "application",
82 | "cache",
83 | "needs",
84 | "your",
85 | "provides",
86 | "addition",
87 | "access",
88 | "cachecontainer",
89 | "reference",
90 | "implementation",
91 | "context",
92 | "core",
93 | "within",
94 | "high"
95 | ],
96 | "timestamp": 1560795538000,
97 | "v": "9.4.15.Final"
98 | },
99 | {
100 | "a": "infinispan-cdi-remote",
101 | "ec": [
102 | "-sources.jar",
103 | "-test-sources.jar",
104 | "-tests.jar",
105 | ".jar",
106 | ".pom"
107 | ],
108 | "g": "org.infinispan",
109 | "id": "org.infinispan:infinispan-cdi-remote:9.4.15.Final",
110 | "p": "bundle",
111 | "tags": [
112 | "module",
113 | "infinispan",
114 | "common",
115 | "parent"
116 | ],
117 | "timestamp": 1560795535000,
118 | "v": "9.4.15.Final"
119 | }
120 | ],
121 | "numFound": 103,
122 | "start": 100
123 | },
124 | "responseHeader": {
125 | "QTime": 0,
126 | "params": {
127 | "core": "",
128 | "fl": "id,g,a,v,p,ec,timestamp,tags",
129 | "indent": "off",
130 | "q": "g:org.infinispan AND v:9.4.15.Final",
131 | "rows": "20",
132 | "sort": "score desc,timestamp desc,g asc,a asc,v desc",
133 | "start": "100",
134 | "version": "2.2",
135 | "wt": "json"
136 | },
137 | "status": 0
138 | }
139 | }
--------------------------------------------------------------------------------
/src/test/java/io/spring/bomr/upgrade/UpgradePolicyTests.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2017-2019 the original author or authors.
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 | * https://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 |
17 | package io.spring.bomr.upgrade;
18 |
19 | import io.spring.bomr.upgrade.version.DependencyVersion;
20 | import org.eclipse.aether.version.InvalidVersionSpecificationException;
21 | import org.junit.Test;
22 |
23 | import static org.assertj.core.api.Assertions.assertThat;
24 |
25 | /**
26 | * Tests for {@link UpgradePolicy}.
27 | *
28 | * @author Andy Wilkinson
29 | */
30 | public class UpgradePolicyTests {
31 |
32 | @Test
33 | public void anyWhenCandidateIsNewerMajorThanCurrentShouldReturnTrue() throws InvalidVersionSpecificationException {
34 | assertThat(UpgradePolicy.ANY.test(version("2.0.0"), version("1.0.0"))).isTrue();
35 | }
36 |
37 | @Test
38 | public void anyWhenCandidateIsNewerMinorThanCurrentShouldReturnTrue() throws InvalidVersionSpecificationException {
39 | assertThat(UpgradePolicy.ANY.test(version("1.1.0"), version("1.0.0"))).isTrue();
40 | }
41 |
42 | @Test
43 | public void anyWhenCandidateIsNewerPatchThanCurrentShouldReturnTrue() throws InvalidVersionSpecificationException {
44 | assertThat(UpgradePolicy.ANY.test(version("1.0.1"), version("1.0.0"))).isTrue();
45 | }
46 |
47 | @Test
48 | public void anyWhenCandidateIsSameAsCurrentShouldReturnFalse() throws InvalidVersionSpecificationException {
49 | assertThat(UpgradePolicy.ANY.test(version("1.0.0"), version("1.0.0"))).isFalse();
50 | }
51 |
52 | @Test
53 | public void anyWhenCandidateIsOlderThanCurrentShouldReturnFalse() throws InvalidVersionSpecificationException {
54 | assertThat(UpgradePolicy.ANY.test(version("2.0.0"), version("2.0.1"))).isFalse();
55 | }
56 |
57 | @Test
58 | public void sameMajorVersionWhenCandidateIsNewerMajorThanCurrentShouldReturnFalse()
59 | throws InvalidVersionSpecificationException {
60 | assertThat(UpgradePolicy.SAME_MAJOR_VERSION.test(version("2.0.0"), version("1.0.0"))).isFalse();
61 | }
62 |
63 | @Test
64 | public void sameMajorVersionWhenCandidateIsNewerMinorThanCurrentShouldReturnTrue()
65 | throws InvalidVersionSpecificationException {
66 | assertThat(UpgradePolicy.SAME_MAJOR_VERSION.test(version("1.1.0"), version("1.0.0"))).isTrue();
67 | }
68 |
69 | @Test
70 | public void sameMajorVersionWhenCandidateIsNewerPatchThanCurrentShouldReturnTrue()
71 | throws InvalidVersionSpecificationException {
72 | assertThat(UpgradePolicy.SAME_MAJOR_VERSION.test(version("1.0.1"), version("1.0.0"))).isTrue();
73 | }
74 |
75 | @Test
76 | public void sameMajorVersionWhenCandidateIsSameAsCurrentShouldReturnFalse()
77 | throws InvalidVersionSpecificationException {
78 | assertThat(UpgradePolicy.SAME_MAJOR_VERSION.test(version("1.0.0"), version("1.0.0"))).isFalse();
79 | }
80 |
81 | @Test
82 | public void sameMajorVersionWhenCandidateIsOlderThanCurrentShouldReturnFalse()
83 | throws InvalidVersionSpecificationException {
84 | assertThat(UpgradePolicy.SAME_MAJOR_VERSION.test(version("2.0.0"), version("2.1.0"))).isFalse();
85 | }
86 |
87 | @Test
88 | public void sameMinorVersionWhenCandidateIsNewerMajorThanCurrentShouldReturnFalse()
89 | throws InvalidVersionSpecificationException {
90 | assertThat(UpgradePolicy.SAME_MINOR_VERSION.test(version("2.0.0"), version("1.0.0"))).isFalse();
91 | }
92 |
93 | @Test
94 | public void sameMinorVersionWhenCandidateIsNewerMinorThanCurrentShouldReturnFalse()
95 | throws InvalidVersionSpecificationException {
96 | assertThat(UpgradePolicy.SAME_MINOR_VERSION.test(version("10.13.1"), version("10.14.1"))).isFalse();
97 | }
98 |
99 | @Test
100 | public void sameMinorVersionWhenCandidateIsNewerPatchThanCurrentShouldReturnTrue()
101 | throws InvalidVersionSpecificationException {
102 | assertThat(UpgradePolicy.SAME_MINOR_VERSION.test(version("1.0.1"), version("1.0.0"))).isTrue();
103 | }
104 |
105 | @Test
106 | public void sameMinorVersionWhenCandidateIsSameAsCurrentShouldReturnFalse()
107 | throws InvalidVersionSpecificationException {
108 | assertThat(UpgradePolicy.SAME_MINOR_VERSION.test(version("1.0.0"), version("1.0.0"))).isFalse();
109 | }
110 |
111 | @Test
112 | public void sameMinorVersionWhenCandidateIsOlderThanCurrentShouldReturnFalse()
113 | throws InvalidVersionSpecificationException {
114 | assertThat(UpgradePolicy.SAME_MINOR_VERSION.test(version("2.1.0"), version("2.1.1"))).isFalse();
115 | }
116 |
117 | private DependencyVersion version(String version) {
118 | return DependencyVersion.parse(version);
119 | }
120 |
121 | }
122 |
--------------------------------------------------------------------------------
/src/main/java/io/spring/bomr/upgrade/Bom.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2017-2019 the original author or authors.
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 | * https://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 |
17 | package io.spring.bomr.upgrade;
18 |
19 | import java.io.File;
20 | import java.io.FileReader;
21 | import java.io.FileWriter;
22 | import java.io.IOException;
23 | import java.util.Collections;
24 | import java.util.LinkedHashMap;
25 | import java.util.Map;
26 |
27 | import javax.xml.parsers.DocumentBuilder;
28 | import javax.xml.parsers.DocumentBuilderFactory;
29 | import javax.xml.xpath.XPath;
30 | import javax.xml.xpath.XPathConstants;
31 | import javax.xml.xpath.XPathExpressionException;
32 | import javax.xml.xpath.XPathFactory;
33 |
34 | import io.spring.bomr.upgrade.BomVersions.BomVersion;
35 | import org.w3c.dom.Document;
36 | import org.w3c.dom.Node;
37 | import org.w3c.dom.NodeList;
38 |
39 | import org.springframework.util.FileCopyUtils;
40 |
41 | /**
42 | * A Maven bom.
43 | *
44 | * @author Andy Wilkinson
45 | */
46 | final class Bom {
47 |
48 | private final File bomFile;
49 |
50 | private final Map managedProjects;
51 |
52 | Bom(File bomFile) {
53 | this.bomFile = bomFile;
54 | Document bom = parseBom(bomFile);
55 | this.managedProjects = extractManagedProjects(bom, new BomVersions(bom));
56 | }
57 |
58 | private Document parseBom(File bomFile) {
59 | DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
60 | try {
61 | DocumentBuilder builder = factory.newDocumentBuilder();
62 | return builder.parse(bomFile);
63 | }
64 | catch (Exception ex) {
65 | throw new RuntimeException(ex);
66 | }
67 | }
68 |
69 | private Map extractManagedProjects(Document bom, BomVersions versions) {
70 | Map projects = new LinkedHashMap<>();
71 | try {
72 | collectProjects("/project/dependencyManagement/dependencies/dependency", projects, bom, versions);
73 | collectProjects("/project/build/pluginManagement/plugins/plugin", projects, bom, versions);
74 | }
75 | catch (Exception ex) {
76 | throw new RuntimeException(ex);
77 | }
78 | return projects;
79 | }
80 |
81 | private void collectProjects(String managedExpression, Map projects, Document bom,
82 | BomVersions versions) throws XPathExpressionException {
83 | XPath xpath = XPathFactory.newInstance().newXPath();
84 | String projectGroupId = xpath.evaluate("/project/groupId/text()", bom);
85 | NodeList managedDependencies = (NodeList) xpath.evaluate(managedExpression, bom, XPathConstants.NODESET);
86 | for (int i = 0; i < managedDependencies.getLength(); i++) {
87 | Node managedDependency = managedDependencies.item(i);
88 | String groupId = xpath.evaluate("groupId/text()", managedDependency);
89 | if (!groupId.equals(projectGroupId)) {
90 | BomVersion version = versions.resolve(xpath.evaluate("version/text()", managedDependency));
91 | if (version != null) {
92 | Project project = projects.computeIfAbsent(new ProjectName(version),
93 | (projectName) -> new Project(projectName, version));
94 | String artifactId = xpath.evaluate("artifactId/text()", managedDependency);
95 | project.getModules().add(new Module(groupId, artifactId));
96 | }
97 | }
98 | }
99 |
100 | }
101 |
102 | Map getManagedProjects() {
103 | return Collections.unmodifiableMap(this.managedProjects);
104 | }
105 |
106 | void applyUpgrade(Upgrade upgrade) {
107 | String versionProperty = upgrade.getProject().getVersion().getProperty();
108 | try {
109 | String updatedBom = FileCopyUtils.copyToString(new FileReader(this.bomFile)).replaceAll(
110 | "<" + versionProperty + ">.*",
111 | "<" + versionProperty + ">" + upgrade.getVersion() + "");
112 | FileCopyUtils.copy(updatedBom, new FileWriter(this.bomFile));
113 | }
114 | catch (IOException ex) {
115 | throw new RuntimeException(ex);
116 | }
117 | }
118 |
119 | void commit(String message) {
120 | try {
121 | if (new ProcessBuilder().command("git", "add", this.bomFile.getAbsolutePath()).start().waitFor() != 0) {
122 | throw new IllegalStateException("git add failed");
123 | }
124 | if (new ProcessBuilder().command("git", "commit", "-m", message).start().waitFor() != 0) {
125 | throw new IllegalStateException("git commit failed");
126 | }
127 | }
128 | catch (InterruptedException ex) {
129 | Thread.currentThread().interrupt();
130 | }
131 | catch (IOException ex) {
132 | throw new RuntimeException(ex);
133 | }
134 | }
135 |
136 | }
137 |
--------------------------------------------------------------------------------
/src/main/java/io/spring/bomr/upgrade/InteractiveUpgradeResolver.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2017-2019 the original author or authors.
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 | * https://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 |
17 | package io.spring.bomr.upgrade;
18 |
19 | import java.util.ArrayList;
20 | import java.util.Collection;
21 | import java.util.LinkedHashMap;
22 | import java.util.List;
23 | import java.util.Map;
24 | import java.util.SortedSet;
25 | import java.util.function.BiConsumer;
26 | import java.util.function.Function;
27 | import java.util.stream.Collectors;
28 |
29 | import io.spring.bomr.upgrade.BomVersions.BomVersion;
30 | import io.spring.bomr.upgrade.version.DependencyVersion;
31 | import org.apache.maven.artifact.versioning.DefaultArtifactVersion;
32 | import org.apache.maven.artifact.versioning.VersionRange;
33 |
34 | import org.springframework.util.StringUtils;
35 |
36 | /**
37 | * Interactive {@link UpgradeResolver} that uses command line input to choose the upgrades
38 | * to apply.
39 | *
40 | * @author Andy Wilkinson
41 | */
42 | final class InteractiveUpgradeResolver implements UpgradeResolver {
43 |
44 | private final VersionResolver versionResolver;
45 |
46 | private final UpgradePolicy upgradePolicy;
47 |
48 | private final Map prohibitedVersions;
49 |
50 | InteractiveUpgradeResolver(VersionResolver versionResolver, UpgradePolicy upgradePolicy,
51 | List prohibitedVersions) {
52 | this.versionResolver = versionResolver;
53 | this.upgradePolicy = upgradePolicy;
54 | this.prohibitedVersions = prohibitedVersions.stream()
55 | .collect(Collectors.toMap(ProhibitedVersions::getProject, Function.identity()));
56 | }
57 |
58 | @Override
59 | public List resolveUpgrades(Collection projects) {
60 | return projects.stream().map(this::resolveUpgrade).filter((upgrade) -> upgrade != null)
61 | .collect(Collectors.toList());
62 | }
63 |
64 | private Upgrade resolveUpgrade(Project project) {
65 | Map> moduleVersions = new LinkedHashMap<>();
66 | ProhibitedVersions prohibitedVersions = this.prohibitedVersions.get(project.getName().getRawName());
67 | project.getModules().forEach((module) -> moduleVersions.put(module.getArtifactId(),
68 | getLaterVersionsForModule(module, project.getVersion())));
69 | List allVersions = moduleVersions.values().stream().flatMap(SortedSet::stream).distinct()
70 | .filter((dependencyVersion) -> isPermitted(dependencyVersion, prohibitedVersions))
71 | .collect(Collectors.toList());
72 | if (allVersions.isEmpty()) {
73 | return null;
74 | }
75 | System.out.println();
76 | System.out.println(project.getName() + " " + project.getVersion().getVersion());
77 | System.out.println();
78 | forEachWithIndex(allVersions, (index, version) -> {
79 | List missingModules = getMissingModules(moduleVersions, version);
80 | System.out.print(" " + (index + 1) + ". " + version);
81 | if (!missingModules.isEmpty()) {
82 | System.out.print(" (Some modules are missing: "
83 | + StringUtils.collectionToDelimitedString(missingModules, ", ") + ")");
84 | }
85 | System.out.println();
86 | });
87 | System.out.println();
88 | String read = System.console().readLine("Please select a version: ");
89 | if (!StringUtils.hasText(read)) {
90 | return null;
91 | }
92 | int selection = Integer.parseInt(read);
93 | return new Upgrade(project, allVersions.get(selection - 1));
94 | }
95 |
96 | private boolean isPermitted(DependencyVersion dependencyVersion, ProhibitedVersions prohibitedVersions) {
97 | if (prohibitedVersions == null) {
98 | return true;
99 | }
100 | for (VersionRange range : prohibitedVersions.getVersions()) {
101 | if (range.containsVersion(new DefaultArtifactVersion(dependencyVersion.toString()))) {
102 | return false;
103 | }
104 | }
105 | return true;
106 | }
107 |
108 | private List getMissingModules(Map> moduleVersions,
109 | DependencyVersion version) {
110 | List missingModules = new ArrayList<>();
111 | moduleVersions.forEach((name, versions) -> {
112 | if (!versions.contains(version)) {
113 | missingModules.add(name);
114 | }
115 | });
116 | return missingModules;
117 | }
118 |
119 | private SortedSet getLaterVersionsForModule(Module module, BomVersion currentVersion) {
120 | SortedSet versions = this.versionResolver.resolveVersions(module);
121 | versions.removeIf((candidate) -> !this.upgradePolicy.test(candidate, currentVersion.getVersion()));
122 | return versions;
123 | }
124 |
125 | private void forEachWithIndex(Collection collection, BiConsumer consumer) {
126 | int i = 0;
127 | for (T item : collection) {
128 | consumer.accept(i++, item);
129 | }
130 | }
131 |
132 | }
133 |
--------------------------------------------------------------------------------
/src/main/java/io/spring/bomr/verify/VerifiableBom.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2017-2019 the original author or authors.
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 | * https://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 |
17 | package io.spring.bomr.verify;
18 |
19 | import java.io.File;
20 | import java.io.IOException;
21 | import java.net.URI;
22 | import java.util.List;
23 | import java.util.Properties;
24 | import java.util.function.BiFunction;
25 | import java.util.stream.Collectors;
26 | import java.util.stream.IntStream;
27 |
28 | import javax.xml.parsers.DocumentBuilder;
29 | import javax.xml.parsers.DocumentBuilderFactory;
30 | import javax.xml.xpath.XPath;
31 | import javax.xml.xpath.XPathConstants;
32 | import javax.xml.xpath.XPathExpressionException;
33 | import javax.xml.xpath.XPathFactory;
34 |
35 | import io.spring.bomr.verify.MavenInvoker.MavenInvocationFailedException;
36 | import org.apache.maven.shared.invoker.MavenInvocationException;
37 | import org.w3c.dom.Document;
38 | import org.w3c.dom.Node;
39 | import org.w3c.dom.NodeList;
40 |
41 | /**
42 | * A representation of a Maven bom intended for verification.
43 | *
44 | * @author Andy Wilkinson
45 | */
46 | class VerifiableBom {
47 |
48 | private final List managedDependencies;
49 |
50 | private final List repositories;
51 |
52 | private final String groupId;
53 |
54 | private final String artifactId;
55 |
56 | private final String version;
57 |
58 | VerifiableBom(MavenInvoker mavenInvoker, File bomFile) {
59 | try {
60 | File effectiveBomFile = createEffectiveBomFile(mavenInvoker, bomFile);
61 | Document effectiveBom = parseBom(effectiveBomFile);
62 | XPath xpath = XPathFactory.newInstance().newXPath();
63 | this.managedDependencies = asList(xpath, "/project/dependencyManagement/dependencies/dependency",
64 | effectiveBom, this::createManagedDependency);
65 | this.groupId = xpath.evaluate("/project/groupId/text()", effectiveBom);
66 | this.artifactId = xpath.evaluate("/project/artifactId/text()", effectiveBom);
67 | this.version = xpath.evaluate("/project/version/text()", effectiveBom);
68 | this.repositories = asList(xpath, "/project/repositories/repository", effectiveBom, this::createRepository);
69 | }
70 | catch (Exception ex) {
71 | throw new RuntimeException(ex);
72 | }
73 | }
74 |
75 | public List getManagedDependencies() {
76 | return this.managedDependencies;
77 | }
78 |
79 | public List getRepositories() {
80 | return this.repositories;
81 | }
82 |
83 | String getGroupId() {
84 | return this.groupId;
85 | }
86 |
87 | String getArtifactId() {
88 | return this.artifactId;
89 | }
90 |
91 | String getVersion() {
92 | return this.version;
93 | }
94 |
95 | private List asList(XPath xpath, String expression, Document effectiveBom, BiFunction mapper)
96 | throws Exception {
97 | NodeList nodeList = (NodeList) xpath.evaluate(expression, effectiveBom, XPathConstants.NODESET);
98 | return IntStream.range(0, nodeList.getLength()).mapToObj(nodeList::item)
99 | .map((node) -> mapper.apply(xpath, node)).collect(Collectors.toList());
100 | }
101 |
102 | private ManagedDependency createManagedDependency(XPath xpath, Node node) {
103 | try {
104 | String groupId = xpath.evaluate("groupId/text()", node);
105 | String artifactId = xpath.evaluate("artifactId/text()", node);
106 | String classifier = xpath.evaluate("classifier/text()", node);
107 | String type = xpath.evaluate("type/text()", node);
108 | return new ManagedDependency(groupId, artifactId, classifier, type);
109 | }
110 | catch (XPathExpressionException ex) {
111 | throw new RuntimeException(ex);
112 | }
113 | }
114 |
115 | private Repository createRepository(XPath xpath, Node node) {
116 | try {
117 | String id = xpath.evaluate("id/text()", node);
118 | String url = xpath.evaluate("url/text()", node);
119 | boolean snapshotsEnabled = Boolean.valueOf(xpath.evaluate("snapshots/enabled/text()", node));
120 | return new Repository(id, URI.create(url), snapshotsEnabled);
121 | }
122 | catch (XPathExpressionException ex) {
123 | throw new RuntimeException(ex);
124 | }
125 | }
126 |
127 | private File createEffectiveBomFile(MavenInvoker mavenInvoker, File bomFile)
128 | throws IOException, MavenInvocationException {
129 | File effectiveBomFile = File.createTempFile("effective-", ".pom");
130 | Properties properties = new Properties();
131 | properties.setProperty("output", effectiveBomFile.getAbsolutePath());
132 | try {
133 | mavenInvoker.invoke(bomFile, properties, "help:effective-pom");
134 | return effectiveBomFile;
135 | }
136 | catch (MavenInvocationFailedException ex) {
137 | System.err.println("Failed to create effective bom from '" + bomFile.getAbsolutePath() + "':");
138 | ex.getOutputLines().forEach(System.err::println);
139 | System.exit(-1);
140 | return null;
141 | }
142 | }
143 |
144 | private Document parseBom(File bomFile) {
145 | DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
146 | try {
147 | DocumentBuilder builder = factory.newDocumentBuilder();
148 | return builder.parse(bomFile);
149 | }
150 | catch (Exception ex) {
151 | throw new RuntimeException(ex);
152 | }
153 | }
154 |
155 | }
156 |
--------------------------------------------------------------------------------
/gradlew:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env sh
2 |
3 | #
4 | # Copyright 2015 the original author or authors.
5 | #
6 | # Licensed under the Apache License, Version 2.0 (the "License");
7 | # you may not use this file except in compliance with the License.
8 | # You may obtain a copy of the License at
9 | #
10 | # http://www.apache.org/licenses/LICENSE-2.0
11 | #
12 | # Unless required by applicable law or agreed to in writing, software
13 | # distributed under the License is distributed on an "AS IS" BASIS,
14 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 | # See the License for the specific language governing permissions and
16 | # limitations under the License.
17 | #
18 |
19 | ##############################################################################
20 | ##
21 | ## Gradle start up script for UN*X
22 | ##
23 | ##############################################################################
24 |
25 | # Attempt to set APP_HOME
26 | # Resolve links: $0 may be a link
27 | PRG="$0"
28 | # Need this for relative symlinks.
29 | while [ -h "$PRG" ] ; do
30 | ls=`ls -ld "$PRG"`
31 | link=`expr "$ls" : '.*-> \(.*\)$'`
32 | if expr "$link" : '/.*' > /dev/null; then
33 | PRG="$link"
34 | else
35 | PRG=`dirname "$PRG"`"/$link"
36 | fi
37 | done
38 | SAVED="`pwd`"
39 | cd "`dirname \"$PRG\"`/" >/dev/null
40 | APP_HOME="`pwd -P`"
41 | cd "$SAVED" >/dev/null
42 |
43 | APP_NAME="Gradle"
44 | APP_BASE_NAME=`basename "$0"`
45 |
46 | # Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
47 | DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
48 |
49 | # Use the maximum available, or set MAX_FD != -1 to use that value.
50 | MAX_FD="maximum"
51 |
52 | warn () {
53 | echo "$*"
54 | }
55 |
56 | die () {
57 | echo
58 | echo "$*"
59 | echo
60 | exit 1
61 | }
62 |
63 | # OS specific support (must be 'true' or 'false').
64 | cygwin=false
65 | msys=false
66 | darwin=false
67 | nonstop=false
68 | case "`uname`" in
69 | CYGWIN* )
70 | cygwin=true
71 | ;;
72 | Darwin* )
73 | darwin=true
74 | ;;
75 | MINGW* )
76 | msys=true
77 | ;;
78 | NONSTOP* )
79 | nonstop=true
80 | ;;
81 | esac
82 |
83 | CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
84 |
85 | # Determine the Java command to use to start the JVM.
86 | if [ -n "$JAVA_HOME" ] ; then
87 | if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
88 | # IBM's JDK on AIX uses strange locations for the executables
89 | JAVACMD="$JAVA_HOME/jre/sh/java"
90 | else
91 | JAVACMD="$JAVA_HOME/bin/java"
92 | fi
93 | if [ ! -x "$JAVACMD" ] ; then
94 | die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
95 |
96 | Please set the JAVA_HOME variable in your environment to match the
97 | location of your Java installation."
98 | fi
99 | else
100 | JAVACMD="java"
101 | which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
102 |
103 | Please set the JAVA_HOME variable in your environment to match the
104 | location of your Java installation."
105 | fi
106 |
107 | # Increase the maximum file descriptors if we can.
108 | if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
109 | MAX_FD_LIMIT=`ulimit -H -n`
110 | if [ $? -eq 0 ] ; then
111 | if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
112 | MAX_FD="$MAX_FD_LIMIT"
113 | fi
114 | ulimit -n $MAX_FD
115 | if [ $? -ne 0 ] ; then
116 | warn "Could not set maximum file descriptor limit: $MAX_FD"
117 | fi
118 | else
119 | warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
120 | fi
121 | fi
122 |
123 | # For Darwin, add options to specify how the application appears in the dock
124 | if $darwin; then
125 | GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
126 | fi
127 |
128 | # For Cygwin, switch paths to Windows format before running java
129 | if $cygwin ; then
130 | APP_HOME=`cygpath --path --mixed "$APP_HOME"`
131 | CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
132 | JAVACMD=`cygpath --unix "$JAVACMD"`
133 |
134 | # We build the pattern for arguments to be converted via cygpath
135 | ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
136 | SEP=""
137 | for dir in $ROOTDIRSRAW ; do
138 | ROOTDIRS="$ROOTDIRS$SEP$dir"
139 | SEP="|"
140 | done
141 | OURCYGPATTERN="(^($ROOTDIRS))"
142 | # Add a user-defined pattern to the cygpath arguments
143 | if [ "$GRADLE_CYGPATTERN" != "" ] ; then
144 | OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
145 | fi
146 | # Now convert the arguments - kludge to limit ourselves to /bin/sh
147 | i=0
148 | for arg in "$@" ; do
149 | CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
150 | CHECK2=`echo "$arg"|egrep -c "^-"` ### Determine if an option
151 |
152 | if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then ### Added a condition
153 | eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
154 | else
155 | eval `echo args$i`="\"$arg\""
156 | fi
157 | i=$((i+1))
158 | done
159 | case $i in
160 | (0) set -- ;;
161 | (1) set -- "$args0" ;;
162 | (2) set -- "$args0" "$args1" ;;
163 | (3) set -- "$args0" "$args1" "$args2" ;;
164 | (4) set -- "$args0" "$args1" "$args2" "$args3" ;;
165 | (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
166 | (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
167 | (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
168 | (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
169 | (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
170 | esac
171 | fi
172 |
173 | # Escape application args
174 | save () {
175 | for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
176 | echo " "
177 | }
178 | APP_ARGS=$(save "$@")
179 |
180 | # Collect all arguments for the java command, following the shell quoting and substitution rules
181 | eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
182 |
183 | # by default we should be in the correct project dir, but when run from Finder on Mac, the cwd is wrong
184 | if [ "$(uname)" = "Darwin" ] && [ "$HOME" = "$PWD" ]; then
185 | cd "$(dirname "$0")"
186 | fi
187 |
188 | exec "$JAVACMD" "$@"
189 |
--------------------------------------------------------------------------------