7263768820

Committed 19 Dec 2023 03:13PM UTC coverage: 49.404% (+1.5%) from 47.873%

Build # 7263768820

Build Type

Pull #159

github

Committed by

web-flow

Commit Message

Merge e50749a62 into 1d60d9c17

Pull Request Pull Request #159: #158: VersionRange with open boundaries

Run Details

1127 of 2459 branches covered (0.0%)

Branch coverage included in aggregate %.

2812 of 5514 relevant lines covered (51.0%)

2.11 hits per line

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

69.46

cli/src/main/java/com/devonfw/tools/ide/version/VersionRange.java

package com.devonfw.tools.ide.version;

/**
 * Container for a range of versions. The lower and upper bounds can be exclusive or inclusive. If a bound is null, it
 * means that this direction is unbounded. The boolean defining whether this bound is inclusive or exclusive is ignored
 * in this case.
 */
public final class VersionRange implements Comparable<VersionRange> {

  private final VersionIdentifier min;

  private final VersionIdentifier max;

  private final boolean leftIsExclusive;

  private final boolean rightIsExclusive;

  private static final String VERSION_SEPARATOR = ">";

  private static final String START_EXCLUDING_PREFIX = "(";

  private static final String START_INCLUDING_PREFIX = "[";

  private static final String END_EXCLUDING_SUFFIX = ")";

  private static final String END_INCLUDING_SUFFIX = "]";

  /**
   * The constructor.
   *
   * @param min the {@link #getMin() minimum}.
   * @param max the {@link #getMax() maximum}.
   */
  public VersionRange(VersionIdentifier min, VersionIdentifier max) {

    super();
    this.min = min;
    this.max = max;
    this.leftIsExclusive = false;
    this.rightIsExclusive = false;
  }

  /**
   * The constructor.
   *
   * @param min the {@link #getMin() minimum}.
   * @param max the {@link #getMax() maximum}.
   * @param boundaryType the {@link BoundaryType} defining whether the boundaries of the range are inclusive or
   *        exclusive.
   */
  public VersionRange(VersionIdentifier min, VersionIdentifier max, BoundaryType boundaryType) {

    super();
    this.min = min;
    this.max = max;
    this.leftIsExclusive = BoundaryType.LEFT_OPEN.equals(boundaryType) || BoundaryType.OPEN.equals(boundaryType);
    this.rightIsExclusive = BoundaryType.RIGHT_OPEN.equals(boundaryType) || BoundaryType.OPEN.equals(boundaryType);
  }

  /**
   * The constructor.
   *
   * @param min the {@link #getMin() minimum}.
   * @param max the {@link #getMax() maximum}.
   * @param leftIsExclusive - {@code true} if the {@link #getMin() minimum} is exclusive, {@code false} otherwise.
   * @param rightIsExclusive - {@code true} if the {@link #getMax() maximum} is exclusive, {@code false} otherwise.
   */
  public VersionRange(VersionIdentifier min, VersionIdentifier max, boolean leftIsExclusive, boolean rightIsExclusive) {

    super();
    this.min = min;
    this.max = max;
    this.leftIsExclusive = leftIsExclusive;
    this.rightIsExclusive = rightIsExclusive;
  }

  /**
   * @return the minimum {@link VersionIdentifier} or {@code null} for no lower bound.
   */
  public VersionIdentifier getMin() {

    return this.min;
  }

  /**
   * @return the maximum {@link VersionIdentifier} or {@code null} for no upper bound.
   */
  public VersionIdentifier getMax() {

    return this.max;
  }

  /**
   * @return {@code true} if the {@link #getMin() minimum} is exclusive, {@code false} otherwise.
   */
  public boolean isLeftExclusive() {

    return this.leftIsExclusive;
  }

  /**
   * @return {@code true} if the {@link #getMax() maximum} is exclusive, {@code false} otherwise.
   */
  public boolean isRightExclusive() {

    return this.rightIsExclusive;
  }

  /**
   * @return the {@link BoundaryType} defining whether the boundaries of the range are inclusive or exclusive.
   */
  public BoundaryType getBoundaryType() {

    if (this.leftIsExclusive && this.rightIsExclusive) {
      return BoundaryType.OPEN;
    } else if (this.leftIsExclusive) {
      return BoundaryType.LEFT_OPEN;
    } else if (this.rightIsExclusive) {
      return BoundaryType.RIGHT_OPEN;
    } else {
      return BoundaryType.CLOSED;
    }
  }

  /**
   * @param version the {@link VersionIdentifier} to check.
   * @return {@code true} if the given {@link VersionIdentifier} is contained in this {@link VersionRange},
   *         {@code false} otherwise.
   */
  public boolean contains(VersionIdentifier version) {

    if (this.min != null) {
      if (this.min.equals(version)) {
        return !this.leftIsExclusive;
      }
      if (version.isLess(this.min)) {
        return false;
      }
    }
    if (this.max != null) {
      if (this.max.equals(version)) {
        return !this.rightIsExclusive;
      }
      if (version.isGreater(this.max)) {
        return false;
      }
    }
    return true;
  }

  @Override
  public int compareTo(VersionRange o) {

    if (this.min == null) {
      if (o == null) {
        return 1; // should never happen
      } else if (o.min == null) {
        return 0;
      }
      return -1;
    }
    int compareMins = this.min.compareTo(o.min);
    if (compareMins == 0) {
      return this.leftIsExclusive == o.leftIsExclusive ? 0 : this.leftIsExclusive ? 1 : -1;
    } else {
      return compareMins;
    }
  }

  @Override
  public boolean equals(Object obj) {

    if (this == obj)
      return true;

    if (obj == null || getClass() != obj.getClass())
      return false;

    VersionRange o = (VersionRange) obj;

    if (this.min == null && this.max == null) {
      return o.min == null && o.max == null;
    }
    if (this.min == null) {
      return o.min == null && this.max.equals(o.max) && this.rightIsExclusive == o.rightIsExclusive;
    }
    if (this.max == null) {
      return this.min.equals(o.min) && o.max == null && this.leftIsExclusive == o.leftIsExclusive;
    }
    return this.min.equals(o.min) && this.leftIsExclusive == o.leftIsExclusive && this.max.equals(o.max)
        && this.rightIsExclusive == o.rightIsExclusive;

  }

  @Override
  public String toString() {

    StringBuilder sb = new StringBuilder();
    sb.append(this.leftIsExclusive ? START_EXCLUDING_PREFIX : START_INCLUDING_PREFIX);
    if (this.min != null) {
      sb.append(this.min);
    }
    sb.append(VERSION_SEPARATOR);
    if (this.max != null) {
      sb.append(this.max);
    }
    sb.append(this.rightIsExclusive ? END_EXCLUDING_SUFFIX : END_INCLUDING_SUFFIX);
    return sb.toString();
  }

  /**
   * @param value the {@link #toString() string representation} of a {@link VersionRange} to parse.
   * @return the parsed {@link VersionRange}.
   */
  public static VersionRange of(String value) {

    boolean leftIsExclusive = false;
    boolean rightIsExclusive = false;

    if (value.startsWith(START_EXCLUDING_PREFIX)) {
      leftIsExclusive = true;
      value = value.substring(START_EXCLUDING_PREFIX.length());
    }
    if (value.startsWith(START_INCLUDING_PREFIX)) {
      value = value.substring(START_INCLUDING_PREFIX.length());
    }
    if (value.endsWith(END_EXCLUDING_SUFFIX)) {
      rightIsExclusive = true;
      value = value.substring(0, value.length() - END_EXCLUDING_SUFFIX.length());
    }
    if (value.endsWith(END_INCLUDING_SUFFIX)) {
      value = value.substring(0, value.length() - END_EXCLUDING_SUFFIX.length());
    }

    int index = value.indexOf(VERSION_SEPARATOR);
    if (index == -1) {
      return null; // log warning?
    }

    VersionIdentifier min = null;
    if (index > 0) {
      min = VersionIdentifier.of(value.substring(0, index));
    }
    VersionIdentifier max = null;
    String maxString = value.substring(index + 1);
    if (!maxString.isEmpty()) {
      max = VersionIdentifier.of(maxString);
    }
    return new VersionRange(min, max, leftIsExclusive, rightIsExclusive);
  }

  public static String getVersionSeparator() {

    return VERSION_SEPARATOR;
  }

  public static String getStartExcludingPrefix() {

    return START_EXCLUDING_PREFIX;
  }

  public static String getStartIncludingPrefix() {

    return START_INCLUDING_PREFIX;
  }

  public static String getEndExcludingSuffix() {

    return END_EXCLUDING_SUFFIX;
  }

  public static String getEndIncludingSuffix() {

    return END_INCLUDING_SUFFIX;
  }

}

1	package com.devonfw.tools.ide.version;
2
3	/**
4	* Container for a range of versions. The lower and upper bounds can be exclusive or inclusive. If a bound is null, it
5	* means that this direction is unbounded. The boolean defining whether this bound is inclusive or exclusive is ignored
6	* in this case.
7	*/
8	public final class VersionRange implements Comparable<VersionRange> {
9
10	private final VersionIdentifier min;
11
12	private final VersionIdentifier max;
13
14	private final boolean leftIsExclusive;
15
16	private final boolean rightIsExclusive;
17
18	private static final String VERSION_SEPARATOR = ">";
19
20	private static final String START_EXCLUDING_PREFIX = "(";
21
22	private static final String START_INCLUDING_PREFIX = "[";
23
24	private static final String END_EXCLUDING_SUFFIX = ")";
25
26	private static final String END_INCLUDING_SUFFIX = "]";
27
28	/**
29	* The constructor.
30	*
31	* @param min the {@link #getMin() minimum}.
32	* @param max the {@link #getMax() maximum}.
33	*/
34	public VersionRange(VersionIdentifier min, VersionIdentifier max) {
35
36	super();	×
37	this.min = min;	×
38	this.max = max;	×
39	this.leftIsExclusive = false;	×
40	this.rightIsExclusive = false;	×
41	}	×
42
43	/**
44	* The constructor.
45	*
46	* @param min the {@link #getMin() minimum}.
47	* @param max the {@link #getMax() maximum}.
48	* @param boundaryType the {@link BoundaryType} defining whether the boundaries of the range are inclusive or
49	* exclusive.
50	*/
51	public VersionRange(VersionIdentifier min, VersionIdentifier max, BoundaryType boundaryType) {
52
53	super();	×
54	this.min = min;	×
55	this.max = max;	×
56	this.leftIsExclusive = BoundaryType.LEFT_OPEN.equals(boundaryType) \|\| BoundaryType.OPEN.equals(boundaryType);	×
57	this.rightIsExclusive = BoundaryType.RIGHT_OPEN.equals(boundaryType) \|\| BoundaryType.OPEN.equals(boundaryType);	×
58	}	×
59
60	/**
61	* The constructor.
62	*
63	* @param min the {@link #getMin() minimum}.
64	* @param max the {@link #getMax() maximum}.
65	* @param leftIsExclusive - {@code true} if the {@link #getMin() minimum} is exclusive, {@code false} otherwise.
66	* @param rightIsExclusive - {@code true} if the {@link #getMax() maximum} is exclusive, {@code false} otherwise.
67	*/
68	public VersionRange(VersionIdentifier min, VersionIdentifier max, boolean leftIsExclusive, boolean rightIsExclusive) {
69
70	super();	2✔
71	this.min = min;	3✔
72	this.max = max;	3✔
73	this.leftIsExclusive = leftIsExclusive;	3✔
74	this.rightIsExclusive = rightIsExclusive;	3✔
75	}	1✔
76
77	/**
78	* @return the minimum {@link VersionIdentifier} or {@code null} for no lower bound.
79	*/
80	public VersionIdentifier getMin() {
81
82	return this.min;	3✔
83	}
84
85	/**
86	* @return the maximum {@link VersionIdentifier} or {@code null} for no upper bound.
87	*/
88	public VersionIdentifier getMax() {
89
90	return this.max;	3✔
91	}
92
93	/**
94	* @return {@code true} if the {@link #getMin() minimum} is exclusive, {@code false} otherwise.
95	*/
96	public boolean isLeftExclusive() {
97
98	return this.leftIsExclusive;	3✔
99	}
100
101	/**
102	* @return {@code true} if the {@link #getMax() maximum} is exclusive, {@code false} otherwise.
103	*/
104	public boolean isRightExclusive() {
105
106	return this.rightIsExclusive;	3✔
107	}
108
109	/**
110	* @return the {@link BoundaryType} defining whether the boundaries of the range are inclusive or exclusive.
111	*/
112	public BoundaryType getBoundaryType() {
113
114	if (this.leftIsExclusive && this.rightIsExclusive) {	×
115	return BoundaryType.OPEN;	×
116	} else if (this.leftIsExclusive) {	×
117	return BoundaryType.LEFT_OPEN;	×
118	} else if (this.rightIsExclusive) {	×
119	return BoundaryType.RIGHT_OPEN;	×
120	} else {
121	return BoundaryType.CLOSED;	×
122	}
123	}
124
125	/**
126	* @param version the {@link VersionIdentifier} to check.
127	* @return {@code true} if the given {@link VersionIdentifier} is contained in this {@link VersionRange},
128	* {@code false} otherwise.
129	*/
130	public boolean contains(VersionIdentifier version) {
131
132	if (this.min != null) {	3!
133	if (this.min.equals(version)) {	5✔
134	return !this.leftIsExclusive;	7✔
135	}
136	if (version.isLess(this.min)) {	5✔
137	return false;	2✔
138	}
139	}
140	if (this.max != null) {	3!
141	if (this.max.equals(version)) {	5✔
142	return !this.rightIsExclusive;	7✔
143	}
144	if (version.isGreater(this.max)) {	5✔
145	return false;	2✔
146	}
147	}
148	return true;	2✔
149	}
150
151	@Override
152	public int compareTo(VersionRange o) {
153
154	if (this.min == null) {	3!
155	if (o == null) {	×
156	return 1; // should never happen	×
157	} else if (o.min == null) {	×
158	return 0;	×
159	}
160	return -1;	×
161	}
162	int compareMins = this.min.compareTo(o.min);	6✔
163	if (compareMins == 0) {	2✔
164	return this.leftIsExclusive == o.leftIsExclusive ? 0 : this.leftIsExclusive ? 1 : -1;	14✔
165	} else {
166	return compareMins;	2✔
167	}
168	}
169
170	@Override
171	public boolean equals(Object obj) {
172
173	if (this == obj)	3!
174	return true;	×
175
176	if (obj == null \|\| getClass() != obj.getClass())	7!
177	return false;	2✔
178
179	VersionRange o = (VersionRange) obj;	3✔
180
181	if (this.min == null && this.max == null) {	6✔
182	return o.min == null && o.max == null;	10!
183	}
184	if (this.min == null) {	3✔
185	return o.min == null && this.max.equals(o.max) && this.rightIsExclusive == o.rightIsExclusive;	18!
186	}
187	if (this.max == null) {	3✔
188	return this.min.equals(o.min) && o.max == null && this.leftIsExclusive == o.leftIsExclusive;	18!
189	}
190	return this.min.equals(o.min) && this.leftIsExclusive == o.leftIsExclusive && this.max.equals(o.max)	26!
191	&& this.rightIsExclusive == o.rightIsExclusive;
192
193	}
194
195	@Override
196	public String toString() {
197
198	StringBuilder sb = new StringBuilder();	4✔
199	sb.append(this.leftIsExclusive ? START_EXCLUDING_PREFIX : START_INCLUDING_PREFIX);	9✔
200	if (this.min != null) {	3!
201	sb.append(this.min);	5✔
202	}
203	sb.append(VERSION_SEPARATOR);	4✔
204	if (this.max != null) {	3✔
205	sb.append(this.max);	5✔
206	}
207	sb.append(this.rightIsExclusive ? END_EXCLUDING_SUFFIX : END_INCLUDING_SUFFIX);	9✔
208	return sb.toString();	3✔
209	}
210
211	/**
212	* @param value the {@link #toString() string representation} of a {@link VersionRange} to parse.
213	* @return the parsed {@link VersionRange}.
214	*/
215	public static VersionRange of(String value) {
216
217	boolean leftIsExclusive = false;	2✔
218	boolean rightIsExclusive = false;	2✔
219
220	if (value.startsWith(START_EXCLUDING_PREFIX)) {	4✔
221	leftIsExclusive = true;	2✔
222	value = value.substring(START_EXCLUDING_PREFIX.length());	5✔
223	}
224	if (value.startsWith(START_INCLUDING_PREFIX)) {	4✔
225	value = value.substring(START_INCLUDING_PREFIX.length());	5✔
226	}
227	if (value.endsWith(END_EXCLUDING_SUFFIX)) {	4✔
228	rightIsExclusive = true;	2✔
229	value = value.substring(0, value.length() - END_EXCLUDING_SUFFIX.length());	9✔
230	}
231	if (value.endsWith(END_INCLUDING_SUFFIX)) {	4✔
232	value = value.substring(0, value.length() - END_EXCLUDING_SUFFIX.length());	9✔
233	}
234
235	int index = value.indexOf(VERSION_SEPARATOR);	4✔
236	if (index == -1) {	3!
237	return null; // log warning?	×
238	}
239
240	VersionIdentifier min = null;	2✔
241	if (index > 0) {	2✔
242	min = VersionIdentifier.of(value.substring(0, index));	6✔
243	}
244	VersionIdentifier max = null;	2✔
245	String maxString = value.substring(index + 1);	6✔
246	if (!maxString.isEmpty()) {	3✔
247	max = VersionIdentifier.of(maxString);	3✔
248	}
249	return new VersionRange(min, max, leftIsExclusive, rightIsExclusive);	8✔
250	}
251
252	public static String getVersionSeparator() {
253
254	return VERSION_SEPARATOR;	×
255	}
256
257	public static String getStartExcludingPrefix() {
258
259	return START_EXCLUDING_PREFIX;	×
260	}
261
262	public static String getStartIncludingPrefix() {
263
264	return START_INCLUDING_PREFIX;	×
265	}
266
267	public static String getEndExcludingSuffix() {
268
269	return END_EXCLUDING_SUFFIX;	×
270	}
271
272	public static String getEndIncludingSuffix() {
273
274	return END_INCLUDING_SUFFIX;	×
275	}
276
277	}

devonfw / IDEasy / 7263768820

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