feat: replace "develop" non-branch name with "main"

README.md

@@ -85,7 +85,7 @@ Version comparisons are carried out in the following order of precedence until o
 2. `minor` - Higher minor versions are considered greater.
 3. `incremental` - Higher incremental versions are considered greater.
 5. `snapshot status` - Release versions are considered greater than snapshot versions.
-4. `branch` - Versions with a `Branch.DEVELOP` are considered greater, others are compared lexicographically.
+4. `branch` - Versions with a `Branch.MAIN` are considered greater, others are compared lexicographically.
 6. `qualifiers` - Qualifiers are compared lexicographically (in order).  A version with fewer qualifiers is considered greater.
 7. `concrete snapshot timestamp` - If both Versions are ConcreteSnapshotVersions their `timestamp`s are compared _lexicographically_ (**not numerically!**  The result for the expected format `yyyyMMdd.HHmmss` is the same, but this is not enforced)
 8. `concrete snapshot buildnumber` - If both Versions are ConcreteSnapshotVersions the one with the higher `buildnumber` is considered greater.
@@ -128,7 +128,7 @@ Otherwise it can be configured with `VersionParser.Characteristics` with these v
 ```java
 final VersionParser parser = new VersionParser(
 
-    // do not set branches (they default to Branch.DEVELOP)
+    // do not set branches (they default to Branch.MAIN)
     VersionParser.Characteristics.IGNORE_BRANCHES,
 
     // do not set any qualifiers
@@ -142,12 +142,12 @@ Generally, a `String` to be parsed into a `Version` has to follow the following
 `major` may be omitted if not leaving the `String` empty, defaults to zero (`0`)  
 `minor` and the leading dot (`.`) may be omitted, defaults to zero (`0`)  
 `incremental` and the leading dot (`.`) may be omitted, defaults to zero (`0`)  
-`branch` and the leading hyphon (`-`) may be omitted if no `qualifiers` are given, defaults to `Branch.DEVELOP`  
+`branch` and the leading hyphon (`-`) may be omitted if no `qualifiers` are given, defaults to `Branch.MAIN`  
 `qualifiers` and the leading hyphon (`-`) may be ommitted
 
 Here are some valid examples:
 ```java
-"1.0.0-develop"
+"1.0.0-main"
 "1"
 ".2"
 "1.3-some_feature-release_candidate-0"
@@ -251,13 +251,13 @@ public class Repository {
 which then can be used like this to retrieve only the desired versions:
 
 ```java
-final List<BaseVersion> developReleases = repository.queryVersions(
+final List<BaseVersion> mainReleases = repository.queryVersions(
     new VersionTypes(
         VersionTypes.PublicationStatusType.RELEASES,
-        VersionTypes.BranchType.DEVELOP));
+        VersionTypes.BranchType.MAIN));
 
-final List<BaseVersion> developSnapshots = repository.queryVersions(
-    VersionTypes.ONLY_DEVELOP_SNAPSHOTS);
+final List<BaseVersion> mainSnapshots = repository.queryVersions(
+    VersionTypes.ONLY_MAIN_SNAPSHOTS);
 
 final List<BaseVersion> all = repository.queryVersions(VersionTypes.ALL);
 

src/main/java/com/sitepark/versioning/Branch.java

@@ -4,46 +4,56 @@
 import java.io.ObjectStreamException;
 import java.io.Serializable;
 
 /**
  * Class, that aims to represent "feature-branches" found in
  * {@link Version}s.
  * By default a {@code Version} does not explicitly define a {@code Branch}
  * (for example {@code "1.0.3"}), in which cases the "non-feature-branch"
- * {@link #DEVELOP} is used.
+ * {@link #MAIN} is used.
  *
  * <p>
  * Branches are compared alphabetically, although for "non-feature-branches"
  * the following rules apply:
  * <ul>
  *   <li>{@code non-feature-branch > feature-branch}</li>
  *   <li>{@code non-feature-branch == non-feature-branch}</li>
  * </ul>
  */
 public final class Branch implements Comparable<Branch>, Serializable {
   private static final long serialVersionUID = 7052868613896268596L;
 
+  private static final String MAIN_VALUE = "main";
   private static final String DEVELOP_VALUE = "develop";
 
   /**
    * Denotes the absense of a "feature-branch".
    */
-  public static final Branch DEVELOP = new Branch(Branch.DEVELOP_VALUE);
+  public static final Branch MAIN = new Branch(Branch.MAIN_VALUE);
+
+  /**
+   * Denotes the absense of a "feature-branch".
+   *
+   * @deprecated use {@link #MAIN} instead
+   */
+  @Deprecated(since = "3.1.0", forRemoval = true)
+  public static final Branch DEVELOP = Branch.MAIN;
 
   private final String value;
 
   /**
    * Class Constructor specifiying a String representation of the Branch.
    *
    * If an empty String is given or
-   * {@code value.equalsIgnoreCase("develop") == true} the Branch will be
+   * {@code value.equalsIgnoreCase("main") == true} (and for legacy reasons also
+   * {@code value.equalsIgnoreCase("develop") == true}) the Branch will be
    * considered a "non-feature-branch".  In this case one may want to use the
-   * {@link #DEVELOP} constant instead.
+   * {@link #MAIN} constant instead.
    *
    * @param value a String representation of a Branch
    * @throws IllegalArgumentException when the value contains spaces or
    *                                  hyphens
    * @throws NullPointerException     when value is <em>null</em>
    */
   public Branch(final String value) {
     if (value.indexOf(' ') != -1) {
       throw new IllegalArgumentException("Branches cannot contain spaces");
@@ -51,30 +61,39 @@
     if (value.indexOf('-') != -1) {
       throw new IllegalArgumentException("Branches cannot contain hyphens");
     }
-    this.value =
-        value.equalsIgnoreCase(Branch.DEVELOP_VALUE) || value.length() == 0
-            ? Branch.DEVELOP_VALUE
-            : value;
+    this.value = this.valueIsMain(value) ? Branch.MAIN_VALUE : value;
   }
 
   /**
    * Returns wether the Branch is considered a "non-feature-branch".
    *
-   * @return {@code true} if the Branch is equal to {@link #DEVELOP},
-   *         {@code false} otherwise
+   * @return {@code true} if the Branch is equal to
+   *         {@link #DEVELOP}/{@link #MAIN}, {@code false} otherwise
+   * @deprecated use {@link #isMain()} instead
    */
+  @Deprecated(since = "3.1.0", forRemoval = true)
   public boolean isDevelop() {
-    return this.value == Branch.DEVELOP_VALUE;
+    return this.value == Branch.MAIN_VALUE;
+  }
+
+  /**
+   * Returns wether the Branch is considered a "non-feature-branch".
+   *
+   * @return {@code true} if the Branch is equal to
+   *         {@link #DEVELOP}/{@link #MAIN}, {@code false} otherwise
+   */
+  public boolean isMain() {
+    return this.value == Branch.MAIN_VALUE;
   }
 
   /**
    * Returns wether the Branch is considered a "feature-branch" or not.
    *
-   * @return {@code true} if the Branch is not equal to {@link #DEVELOP},
-   *         {@code false} otherwise
+   * @return {@code true} if the Branch is not equal to
+   *         {@link #DEVELOP}/{@link #MAIN}, {@code false} otherwise
    */
   public boolean isFeature() {
-    return this.value != Branch.DEVELOP_VALUE;
+    return this.value != Branch.MAIN_VALUE;
   }
 
   @Override
@@ -84,14 +103,14 @@
 
   @Override
   public int compareTo(final Branch other) {
-    switch ((this.isDevelop() ? 1 : 0) + (other.isDevelop() ? 2 : 0)) {
-      case 1: // only this is develop
+    switch ((this.isMain() ? 1 : 0) + (other.isMain() ? 2 : 0)) {
+      case 1: // only this is main
         return 1;
-      case 2: // only other is develop
+      case 2: // only other is main
         return -1;
-      case 3: // both are develop
+      case 3: // both are main
         return 0;
-      default: // neither is develop
+      default: // neither is main
         return this.value.compareTo(other.value);
     }
   }
@@ -108,13 +127,20 @@
 
   /**
    * Assures that the Serializable interface does not create a new instance
-   * of {@code Branch.DEVELOP_VALUE}, which would mess up comparisons in
-   * {@code isDevelop} and {@code isFeature}.
+   * of {@link #MAIN_VALUE}/{@link #DEVELOP_VALUE}, which would mess up
+   * comparisons in {@link #isMain()}/{@link #isDevelop()} and
+   * {@link #isFeature()}.
    */
   private Object readResolve() throws ObjectStreamException {
-    if (this.value.equalsIgnoreCase(Branch.DEVELOP_VALUE) || value.length() == 0) {
-      return Branch.DEVELOP;
+    if (this.valueIsMain(this.value)) {
+      return Branch.MAIN;
     }
     return this;
   }
+
+  private boolean valueIsMain(String value) {
+    return value.length() == 0
+        || value.equalsIgnoreCase(Branch.DEVELOP_VALUE)
+        || value.equalsIgnoreCase(Branch.MAIN_VALUE);
+  }
 }

src/main/java/com/sitepark/versioning/version/Version.java

@@ -3,22 +3,22 @@
 import com.sitepark.versioning.Branch;
 import java.util.List;
 
 /**
  * A representation of a generic Version.
  * This includes the definition of the most basic fields (named after
  * <a href="https://semver.org/">semvers</a> and
  * <a href="https://maven.apache.org/">mavens</a> terminology):
  * <ul>
  *   <li>{@code major}</li>
  *   <li>{@code minor}</li>
  *   <li>{@code incremental}</li>
  *   <li>{@code branch}</li>
  *   <li>{@code qualifiers}</li>
  * </ul>
  * A instance may be described in the commonly used String format of the
  * {@link VersionParser} like so:<br>
  * {@code <major>.<minor>.<incremental>-<branch>-<qualifiers>}
  */
 public sealed interface Version extends Comparable<Version>
     permits AbstractVersion, BaseVersion, ConcreteVersion {
 
@@ -28,7 +28,7 @@
    *
    * @return the major version
    */
   public int getMajor();
 
   /**
    * Returns the {@code minor} version.
@@ -36,7 +36,7 @@
    *
    * @return the minor version
    */
   public int getMinor();
 
   /**
    * Returns the {@code incremental} version.
@@ -44,16 +44,16 @@
    *
    * @return the incremental version
    */
   public int getIncremental();
 
   /**
    * Returns the {@link Branch} of this Version.
    * This is never {@code null}; The absence of a feature branch is denoted
-   * by the {@link Branch#DEVELOP} instance.
+   * by the {@link Branch#MAIN} instance.
    *
    * @return the branch
    */
   public Branch getBranch();
 
   /**
    * Returns all {@code qualifiers} of this Version.
@@ -62,76 +62,76 @@
    *
    * @return the branch
    */
   public List<String> getQualifiers();
 
   /**
    * Returns wether this Version is considered a {@code snapshot}.
    * Depending on the implementing class this may be determined by varying
    * factors.
    *
    * <p>
    * A Version is strictly classifiable into either a {@code snapshot} or a
    * {@code release}.  Meaning that a instance that returns {@code false} is
    * always a {@code release}.
    *
    * @return {@code true} if this Version is considered a {@code snapshot},
    *         {@code false} otherwise
    * @see #isRelease()
    */
   public abstract boolean isSnapshot();
 
   /**
    * Returns wether this Version is considered a {@code release}.
    * Depending on the implementing class this may be determined by varying
    * factors.
    *
    * <p>
    * A Version is strictly classifiable into either a {@code snapshot} or a
    * {@code release}.  Meaning that a instance that returns {@code false} is
    * always a {@code snapshot}.
    *
    * @return {@code true} if this Version is considered a {@code release},
    *         {@code false} otherwise
    * @see #isSnapshot()
    */
   public abstract boolean isRelease();
 
   /**
    * Compares this Version to another Version.
    * The comparison is carried out in the following order of precedence until
    * a field is not considered equal:
    * <ol>
    *   <li>{@code major} - Higher major versions are considered greater.</li>
    *   <li>{@code minor} - Higher minor versions are considered greater.</li>
    *   <li>
    *     {@code incremental} - Higher incremental versions are considered
    *     greater.
    *   </li>
    *   <li>
    *     {@code snapshot status} - Release versions are considered greater
    *     than snapshot versions.
    *   </li>
    *   <li>
    *     {@code branch} - {@link Branch}es are compared as described by
    *     {@link  Branch#compareTo}.
    *   </li>
    *   <li>
    *     {@code qualifiers} - Qualifiers are compared lexicographically (in
    *     order).  A version with fewer qualifiers is considered
    *     greater.
    *   </li>
    * </ol>
    *
    * @param that the version to be compared
    * @return a negative {@code int}, zero ({@code 0}), or a positive
    *         {@code int} as this Version is less than, equal to, or greater
    *         than the specified Version.
    * @see ReleaseVersion#compareTo(Version)
    * @see SnapshotVersion#compareTo(Version)
    * @see ConcreteSnapshotVersion#compareTo(Version)
    */
   @Override
   public default int compareTo(final Version that) {
     return VersionComparator.NATUAL.compare(this, that);
   }
 }

src/main/java/com/sitepark/versioning/version/VersionBuilder.java

@@ -7,38 +7,38 @@
 import java.util.Objects;
 import java.util.concurrent.atomic.AtomicInteger;
 
 /**
  * A builder class to instantiate {@link ReleaseVersion}s,
  * {@link SnapshotVersion}s and {@link ConcreteSnapshotVersion}s.
  * {@code ConcreteSnapshotVersion}s require an additional {@code timestamp} and
  * {@code buildnumber}.
  * All fields have default values.
  *
  * Usage:
  * <pre>new VersionBuilder()
  *    .setMinor(1)
  *    .buildRelease()</pre>
  *
  * <pre>new VersionBuilder()
  *    .setMajor(3)
  *    .setIncremental(1)
  *    .addQualifier("hotfix")
  *    .buildSnapshot();</pre>
  *
  * <pre>new VersionBuilder()
  *    .setMajor(1)
  *    .setBranch(new Branch("new_core_engine"))
  *    .buildConcreteSnapshot(
  *            DateTimeFormatter.ofPattern("yyyyMMdd.HHmmss")
  *                .format(LocalDate.now())
  *            this.buildnumber++);</pre>
  */
 public class VersionBuilder {
   private AtomicInteger major;
   private AtomicInteger minor;
   private AtomicInteger incremental;
   private Branch branch;
   private final List<String> qualifiers;
 
   /**
    * Class Constructor
@@ -47,19 +47,19 @@
     this.major = new AtomicInteger(0);
     this.minor = new AtomicInteger(0);
     this.incremental = new AtomicInteger(0);
-    this.branch = Branch.DEVELOP;
+    this.branch = Branch.MAIN;
     this.qualifiers = Collections.synchronizedList(new LinkedList<>());
   }
 
   /**
    * Specifies a {@code major} to set on {@link Version}s created by this
    * instance.
    * Otherwise defaults to zero ({@code 0}).
    *
    * @param major the major version
    * @return this instance
    * @see Version#getMajor()
    */
   public VersionBuilder setMajor(final int major) {
     this.major.set(major);
     return this;
@@ -76,15 +76,15 @@
     return this.major.get();
   }
 
   /**
    * Specifies a {@code minor} to set on {@link Version}s created by this
    * instance.
    * Otherwise defaults to zero ({@code 0}).
    *
    * @param minor the minor version
    * @return this instance
    * @see Version#getMinor()
    */
   public VersionBuilder setMinor(final int minor) {
     this.minor.set(minor);
     return this;
@@ -101,15 +101,15 @@
     return this.minor.get();
   }
 
   /**
    * Specifies a {@code incremental} to set on {@link Version}s created by
    * this instance.
    * Otherwise defaults to zero ({@code 0}).
    *
    * @param incremental the incremental version
    * @return this instance
    * @see Version#getIncremental()
    */
   public VersionBuilder setIncremental(final int incremental) {
     this.incremental.set(incremental);
     return this;
@@ -126,15 +126,15 @@
     return this.incremental.get();
   }
 
   /**
    * Specifies a {@link Branch} to set on {@link Version}s created by this
    * instance.
-   * Otherwise defaults to {@link Branch#DEVELOP}.
+   * Otherwise defaults to {@link Branch#MAIN}.
    *
    * @param branch the branch to set
    * @return this instance
    * @see Version#getBranch()
    */
   public VersionBuilder setBranch(final Branch branch) {
     this.branch = Objects.requireNonNull(branch);
     return this;
@@ -142,7 +142,7 @@
 
   /**
    * Returns the currently set {@link Branch}.
-   * Defaults to {@link Branch#DEVELOP}.
+   * Defaults to {@link Branch#MAIN}.
    *
    * @return the incremental version
    * @see Version#getBranch()
@@ -151,16 +151,16 @@
     return this.branch;
   }
 
   /**
    * Specifies and overwrites all {@code qualifiers} to set on
    * {@link Version}s created by this instance.
    *
    * @param qualifiers a {@code List} of qualifiers to set
    * @return this instance
    * @throws NullPointerException if {@code qualifiers} contains {@code null}
    * @see #addQualifier(String)
    * @see Version#getQualifiers()
    */
   public VersionBuilder setQualifiers(final List<String> qualifiers) {
     this.qualifiers.clear();
     for (final String qualifier : qualifiers) {
@@ -169,16 +169,16 @@
     return this;
   }
 
   /**
    * Appends a {@code qualifier} to the {@code qualifiers} to set on
    * {@link Version}s created by this instance.
    *
    * @param qualifier the qualifier to append
    * @return this instance
    * @throws NullPointerException if {@code qualifier} is {@code null}
    * @see #setQualifiers(List)
    * @see Version#getQualifiers()
    */
   public VersionBuilder addQualifier(final String qualifier) {
     this.qualifiers.add(Objects.requireNonNull(qualifier));
     return this;
@@ -196,45 +196,45 @@
     return Collections.unmodifiableList(this.qualifiers);
   }
 
   /**
    * Builds a {@link ReleaseVersion} with all set fields.
    * For Fields that were not explicitly specified their default values are
    * applied.
    *
    * @return a new ReleaseVersion
    * @see #buildSnapshot()
    * @see #buildConcreteSnapshot(String, int)
    */
   public ReleaseVersion buildRelease() {
     return new ReleaseVersion(this);
   }
 
   /**
    * Builds a {@link SnapshotVersion} with all set fields.
    * For Fields that were not explicitly specified their default values are
    * applied.
    *
    * @return a new SnapshotVersion
    * @see #buildRelease()
    * @see #buildConcreteSnapshot(String, int)
    */
   public SnapshotVersion buildSnapshot() {
     final SnapshotVersion value = new SnapshotVersion(this);
     return value;
   }
 
   /**
    * Builds a {@link ConcreteSnapshotVersion} with all set fields.
    * This requires the {@code timestamp} and {@code buildnumber} fields to be
    * specified.  Other Fields that were not explicitly specified have their
    * default values applied.
    *
    * @param timestamp the timestamp to set
    * @param buildnumber the buildnumber to set
    * @return a new ConcreteSnapshotVersion
    * @see #buildRelease()
    * @see #buildSnapshot()
    */
   public ConcreteSnapshotVersion buildConcreteSnapshot(
       final String timestamp, final int buildnumber) {
     return new ConcreteSnapshotVersion(this, timestamp, buildnumber);

src/main/java/com/sitepark/versioning/version/VersionParseExecutor.java

@@ -11,7 +11,7 @@
  *
  * @param <R> class of the {@code Version} the implementation attempts to parse
  */
 abstract class VersionParseExecutor<R> {
 
   /**
    * The section of a {@link Version}-String this parser may be in.
@@ -24,20 +24,20 @@
     QUALIFIER;
   }
 
   protected final String string;
   protected final int maxIndex;
   protected final byte flags;
 
   protected char currentChar;
   protected int index = -1;
   protected boolean isLastChar = false;
   protected StringBuilder currentItem = new StringBuilder();
   protected int currentItemLength = 0;
   protected Section currentSection = Section.MAJOR;
 
   protected final VersionBuilder versionBuilder;
 
   VersionParseExecutor(final String string, final byte flags) {
     this.string = string;
     this.maxIndex = string.length() - 1;
     this.flags = flags;
@@ -50,12 +50,12 @@
    * @throws ParseException if the String is not compliant with the required
    *                        format
    */
   public R execute() throws ParseException {
     if (this.maxIndex == -1) {
       this.fail();
     }
     do {
       this.isLastChar = ++this.index == this.maxIndex;
       this.currentChar = this.string.charAt(this.index);
       this.step();
     } while (!this.isLastChar);
@@ -65,7 +65,7 @@
   /**
    * Consumes a single char
    */
   private void step() throws ParseException {
     switch (this.currentChar) {
       case ' ':
       case '\n':
@@ -199,15 +199,16 @@
   /**
    * Adds the {@link #currentItem} as {@code branch} to the
    * {@link #versionBuilder} and advances to the {@link Section#QUALIFIER}.
-   * Defaults to {@link Branch#DEVELOP} if the
+   * Defaults to {@link Branch#MAIN} if the
    * {@link VersionParser.Characteristics#IGNORE_BRANCHES} flag is set.
    *
    * @see VersionBuilder#setBranch(Branch)
    */
   protected void addBranch() {
     final String branch = this.currentItem.toString();
     if (!VersionParser.Characteristics.IGNORE_BRANCHES.isSet(this.flags)
+        && !branch.equalsIgnoreCase("main")
         && !branch.equalsIgnoreCase("develop")) {
       this.versionBuilder.setBranch(new Branch(branch));
     }
     this.resetCurrentItem();

src/main/java/com/sitepark/versioning/version/VersionParser.java

@@ -3,87 +3,87 @@
 import com.sitepark.versioning.Branch;
 import java.text.ParseException;
 
 /**
  * A class to parse Strings of a certain format into {@link Version}s.
  * Generally this format is as follows:<br>
  * {@code "<major>.<minor>.<incremental>-<branch>-<qualifiers>"}
  * <ul>
  *   <li>
  *     {@code major} may be omitted if not leaving the String empty, defaults
  *     to zero ({@code 0})
  *   </li>
  *   <li>
  *     {@code minor} and the leading dot ({@code .}) may be omitted, defaults
  *     to zero ({@code 0})
  *   </li>
  *   <li>
  *     {@code incremental} and the leading dot ({@code .}) may be omitted,
  *     defaults to zero ({@code 0})
  *   </li>
  *   <li>
  *     {@code branch} and the leading hyphon ({@code -}) may be omitted if no
- *     {@code qualifiers} are given, defaults to {@link Branch#DEVELOP}
+ *     {@code qualifiers} are given, defaults to {@link Branch#MAIN}
  *   </li>
  *   <li>
  *     {@code qualifiers} and the leading hyphon ({@code -}) may be ommitted
  *   </li>
  * </ul>
  *
  * <p>
  * Therefore all of these are valid examples:
  * <pre>
- *    "1.0.0-develop"
+ *    "1.0.0-main"
  *    "1"
  *    ".2"
  *    "1.3-some_feature-release_candidate-0"
  *    "-experimental"
  * </pre>
  *
  * <p>
  * When parsing {@link PotentialSnapshotVersion}s the {@code qualifier}
  * {@code "SNAPSHOT"} denotes the {@code Version} to be a {@link
  * SnapshotVersion} if at the end of the String.
  * <pre>
  *    // SnapshotVersion
  *    parser.parsePotentialSnapshot("1.0-FEATURE-SNAPSHOT");
  *    // ReleaseVersion
  *    parser.parsePotentialSnapshot("1.0-SNAPSHOT-FEATURE");
  * </pre>
  *
  * <p>
  * For {@link PotentialConcreteSnapshotVersion}s these are instead a timestamp
  * of the form {@code yyyyMMdd.HHmmss} and a buildnumber.
  * <pre>
  *    // ConcreteSnapshotVersion
  *    parser.parsePotentialConcreteSnapshot("1.0-20230605.123612-1);
  *    // ReleaseVersion
  *    parser.parsePotentialConcreteSnapshot("1.0-1-20230605.123612);
  * </pre>
  *
  * <p>
  * A VersionParser instance may be configured by specifiying one or more
  * {@link Characteristics} in the constructor.
  * <ul>
  *   <li>
  *     {@link Characteristics#IGNORE_BRANCHES}<br>
- *     Always set the {@link Branch} to {@link Branch#DEVELOP}.  This does not
+ *     Always set the {@link Branch} to {@link Branch#MAIN}.  This does not
  *     cause {@code branch} keywords to be added to the {@code qualifiers}.
  *   </li>
  *   <li>
  *     {@link Characteristics#IGNORE_QUALIFIERS}<br>
  *     Do not set any {@code qualifiers}.  Does not influence the {@code branch}
  *     or the exclusive {@code qualifiers} for {@link SnapshotVersion}s
  *     ({@code "SNAPSHOT"}) or {@link ConcreteSnapshotVersion}s
  *     ({@code timestamp} and {@code buildnumber}). </li>
  * </ul>
  *
  * <p>
  * This class is immutable and thread-safe.
  *
  * @see #parseRelease(String)
  * @see #parseBaseVersion(String)
  * @see #parseConcreteVersion(String)
  */
 public class VersionParser {
 
   /**
@@ -91,14 +91,14 @@
    */
   public static final VersionParser DEFAULT_PARSER = new VersionParser();
 
   private final byte flags;
 
   /**
    * Options to configure a {@link VersionParser} instance with.
    */
   public enum Characteristics {
     /**
-     * Always set the {@link Branch} to {@link Branch#DEVELOP}.
+     * Always set the {@link Branch} to {@link Branch#MAIN}.
      * This does not cause {@code branch} keywords to be added to the
      * {@code qualifiers}.
      */
@@ -112,17 +112,17 @@
      */
     IGNORE_QUALIFIERS((byte) 0b0000_0010);
 
     private final byte mask;
 
     private Characteristics(final byte mask) {
       this.mask = mask;
     }
 
     int getMask() {
       return this.mask;
     }
 
     boolean isSet(final byte value) {
       return (value & this.mask) == this.mask;
     }
   }
@@ -141,116 +141,116 @@
     this.flags = flags;
   }
 
   /**
    * Parses a String into a {@link ReleaseVersion}.
    *
    * The required format is as follows:<br>
    * {@code "<major>.<minor>.<incremental>-<branch>-<qualifiers>"}
    * <ul>
    *   <li>
    *     {@code major} may be omitted if not leaving the String empty,
    *     defaults to zero ({@code 0})
    *   </li>
    *   <li>
    *     {@code minor} and the leading dot ({@code .}) may be omitted,
    *     defaults to zero ({@code 0})
    *   </li>
    *   <li>
    *     {@code incremental} and the leading dot ({@code .}) may be omitted,
    *     defaults to zero ({@code 0})
    *   </li>
    *   <li>
    *     {@code branch} and the leading hyphon ({@code -}) may be omitted if
-   *     no {@code qualifiers} are given, defaults to {@link Branch#DEVELOP}
+   *     no {@code qualifiers} are given, defaults to {@link Branch#MAIN}
    *   </li>
    *   <li>
    *     {@code qualifiers} and the leading hyphon ({@code -}) may be ommitted
    *   </li>
    * </ul>
    *
    * <p>
    * All of these are valid examples:
    * <pre>
-   *    "1.0.0-develop"
+   *    "1.0.0-main"
    *    "1"
    *    ".2"
    *    "1.3-some_feature-release_candidate-0"
    *    "-experimental"
    * </pre>
    *
    * <p>
    * {@code qualifiers}, that imply the {@link Version} not beeing a
    * {@link ReleaseVersion} in the {@link #parseBaseVersion(String)} and
    * {@link #parseConcreteVersion(String)} methods do not have any special
    * meaning here.
    *
    * @param version the String to be parsed
    * @return the resulting {@link ReleaseVersion}
    * @throws ParseException when the given String is not compatible with the
    *                        required format
    * @see #parseBaseVersion(String)
    * @see #parseConcreteVersion(String)
    */
   public ReleaseVersion parseRelease(final String version) throws ParseException {
     return new ReleaseParseExecutor(version, this.flags).execute();
   }
 
   /**
    * Parses a String into either a {@link SnapshotVersion} or a
    * {@link ReleaseVersion}.
    *
    * The required format is as follows:<br>
    * {@code "<major>.<minor>.<incremental>-<branch>-<qualifiers>-SNAPSHOT"}
    * <ul>
    *   <li>
    *     {@code major} may be omitted if not leaving the String empty,
    *     defaults to zero ({@code 0})
    *   </li>
    *   <li>
    *     {@code minor} and the leading dot ({@code .}) may be omitted,
    *     defaults to zero ({@code 0})
    *   </li>
    *   <li>
    *     {@code incremental} and the leading dot ({@code .}) may be omitted,
    *     defaults to zero ({@code 0})
    *   </li>
    *   <li>
    *     {@code branch} and the leading hyphon ({@code -}) may be omitted if
-   *     no {@code qualifiers} are given, defaults to {@link Branch#DEVELOP}
+   *     no {@code qualifiers} are given, defaults to {@link Branch#MAIN}
    *   </li>
    *   <li>
    *     {@code qualifiers} and the leading hyphon ({@code -}) may be ommitted
    *   </li>
    *   <li>
    *     {@code "-SNAPSHOT"} causes the result to be a {@code SnapshotVersion}
    *     if present and a {@code ReleaseVersion} otherwise
    *   </li>
    * </ul>
    *
    * <p>
    * All of these are valid examples:
    * <pre>
-   *    "1.0.0-develop"
+   *    "1.0.0-main"
    *    "1"
    *    ".2"
    *    "1.3-some_feature-release_candidate-0"
    *    "-experimental"
    * </pre>
    *
    * <p>
    * If the {@code "SNAPSHOT"} {@code qualifier} is not located at the very
    * end it is interpreted as any other {@code qualifier} or as
    * {@code branch} depending on it's position.
    *
    * @param version the String to be parsed
    * @return the resulting {@link Version} wrapped inside a
    *          {@link PotentialSnapshotVersion}
    * @throws ParseException when the given String is not compatible with the
    *                        required format
    * @deprecated use {@link #parseBaseVersion(String)} instead
    * @see #parseRelease(String)
    * @see #parsePotentialConcreteSnapshot(String)
    */
   @SuppressWarnings("removal")
   @Deprecated(since = "3.0.0", forRemoval = true)
   public PotentialSnapshotVersion parsePotentialSnapshot(final String version)
@@ -259,70 +259,70 @@
         new BaseVersionParseExecutor(version, this.flags).execute());
   }
 
   /**
    * Parses a String into either a {@link SnapshotVersion} or a
    * {@link ReleaseVersion}.
    *
    * The required format is as follows:<br>
    * {@code "<major>.<minor>.<incremental>-<branch>-<qualifiers>-SNAPSHOT"}
    * <ul>
    *   <li>
    *     {@code major} may be omitted if not leaving the String empty,
    *     defaults to zero ({@code 0})
    *   </li>
    *   <li>
    *     {@code minor} and the leading dot ({@code .}) may be omitted,
    *     defaults to zero ({@code 0})
    *   </li>
    *   <li>
    *     {@code incremental} and the leading dot ({@code .}) may be omitted,
    *     defaults to zero ({@code 0})
    *   </li>
    *   <li>
    *     {@code branch} and the leading hyphon ({@code -}) may be omitted if
-   *     no {@code qualifiers} are given, defaults to {@link Branch#DEVELOP}
+   *     no {@code qualifiers} are given, defaults to {@link Branch#MAIN}
    *   </li>
    *   <li>
    *     {@code qualifiers} and the leading hyphon ({@code -}) may be ommitted
    *   </li>
    *   <li>
    *     {@code "-SNAPSHOT"} causes the result to be a {@code SnapshotVersion}
    *     if present and a {@code ReleaseVersion} otherwise
    *   </li>
    * </ul>
    *
    * <p>
    * All of these are valid examples:
    * <pre>
-   *    "1.0.0-develop"
+   *    "1.0.0-main"
    *    "1"
    *    ".2"
    *    "1.3-some_feature-release_candidate-0"
    *    "-experimental"
    * </pre>
    *
    * <p>
    * If the {@code "SNAPSHOT"} {@code qualifier} is not located at the very
    * end it is interpreted as any other {@code qualifier} or as
    * {@code branch} depending on it's position.
    *
    * @param version the String to be parsed
    * @return the resulting {@link BaseVersion}
    * @throws ParseException when the given String is not compatible with the
    *                        required format
    * @see #parseRelease(String)
    * @see #parseConcreteVersion(String)
    */
   public BaseVersion parseBaseVersion(final String version) throws ParseException {
     return new BaseVersionParseExecutor(version, this.flags).execute();
   }
 
   /**
    * Parses a String into either a {@link ConcreteSnapshotVersion} or a
    * {@link ReleaseVersion}.
    *
    * The required format is as follows:<br>
    * {@code "<major>.<minor>.<incremental>-<branch>-<qualifiers>-<timestamp>-<buildnumber>"}
    * <ul>
    *   <li>
    *     {@code major} may be omitted if not leaving the String empty,
@@ -338,7 +338,7 @@
    *   </li>
    *   <li>
    *     {@code branch} and the leading hyphon ({@code -}) may be omitted if
-   *     no {@code qualifiers} are given, defaults to {@link Branch#DEVELOP}
+   *     no {@code qualifiers} are given, defaults to {@link Branch#MAIN}
    *   </li>
    *   <li>
    *     {@code qualifiers} and the leading hyphon ({@code -}) may be ommitted
@@ -353,7 +353,7 @@
    * <p>
    * All of these are valid examples:
    * <pre>
-   *    "1.0.0-develop"
+   *    "1.0.0-main"
    *    "1"
    *    ".2"
    *    "1.3-some_feature-release_candidate-0"
@@ -383,12 +383,12 @@
         new ConcreteVersionParseExecutor(version, this.flags).execute());
   }
 
   /**
    * Parses a String into either a {@link ConcreteSnapshotVersion} or a
    * {@link ReleaseVersion}.
    *
    * The required format is as follows:<br>
    * {@code "<major>.<minor>.<incremental>-<branch>-<qualifiers>-<timestamp>-<buildnumber>"}
    * <ul>
    *   <li>
    *     {@code major} may be omitted if not leaving the String empty,
@@ -404,7 +404,7 @@
    *   </li>
    *   <li>
    *     {@code branch} and the leading hyphon ({@code -}) may be omitted if
-   *     no {@code qualifiers} are given, defaults to {@link Branch#DEVELOP}
+   *     no {@code qualifiers} are given, defaults to {@link Branch#MAIN}
    *   </li>
    *   <li>
    *     {@code qualifiers} and the leading hyphon ({@code -}) may be ommitted
@@ -419,7 +419,7 @@
    * <p>
    * All of these are valid examples:
    * <pre>
-   *    "1.0.0-develop"
+   *    "1.0.0-main"
    *    "1"
    *    ".2"
    *    "1.3-some_feature-release_candidate-0"