Clever Semantic Versioning

1. Overview

Given a version number MAJOR.MINOR.PATCH-EXTRA+META, increment the:

1. MAJOR when making backward incompatible changes

2. MINOR when adding functionality in a backward compatible manner.

3. PATCH when making backward compatible bug fixes.

4. EXTRA for pre-releases or other additional versioning parameters.

2. Clever Semantic Versioning Specification

The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD","SHOULD NOT", "RECOMMENDED","NOT RECOMMENDED", "MAY", and "OPTIONAL" in this document are to be interpreted as described in BCP 14 [RFC2119] [RFC8174] when, and only when, they appear in all capitals, as shown here.

1. A normal version number MUST take the form X.Y.Z where X, Y, and Z are non-negative integers, and MUST NOT contain leading zeroes. X is the major version, Y is the minor version, and Z is the patch version. X, Y, and Z MUST be representable in a thirty-two-bit unsigned integer, i.e. strictly less than 4,294,967,296.
2. Once a versioned package has been released, the contents of that version MUST NOT be modified. Any modifications MUST be released as a new version.
3. Major version zero (0.y.z) is for initial development. Anything MAY change at any time. The artifact SHOULD NOT be considered stable.
4. Version 1.0.0 defines the artifact. The way in which the version number is incremented after this release is dependent on the version class of the component.
5. Patch version Z (x.y.Z | x > 0) MUST be incremented if only backward compatible bug fixes are introduced. A bug fix is defined as an internal change that fixes incorrect documented behavior or improves performance characteristics while adding no new functionality.
6. Minor version Y (x.Y.z | x > 0) MUST be incremented if new, backward compatible functionality is introduced to the component. It MUST be incremented if any public functionality is marked as deprecated and it MUST be incremented if new functionality is exposed publicly through the versioned component. It MAY include patch level changes. Patch version MUST be reset to 0 when minor version is incremented. The minor version MUST NOT increment if the major version is eligible to be incremented at this time.
7. Major version X (X.y.z | X > 0) MUST be incremented if any backward incompatible changes are introduced to the component being versioned. It MAY also include minor and patch and minor level changes. Patch and minor versions MUST be reset to 0 when major version is incremented.
8. Extra version MAY be denoted by appending a hyphen and a series of dot separated identifiers immediately following the patch version. Identifiers MUST comprise only ASCII alphanumerics and hyphens [0-9A-Za-z-]. Identifiers MUST NOT be empty. Numeric identifiers MUST NOT include leading zeroes. Extra versions have a lower precedence than the associated normal version. An extra version containing only purely numeric identifiers represents a subversion and will follow the same format and rules as a normal version (see dependent version class below). Any other extra version indicates a pre-release and that the version is unstable and might not satisfy the intended compatibility requirements as denoted by its associated normal version.
9. Build metadata MAY be denoted by appending a plus sign and a series of dot separated identifiers immediately following the patch or extra version. Identifiers MUST comprise only ASCII alphanumerics and hyphens [0-9A-Za-z-]. Identifiers MUST NOT be empty. Build metadata MUST be ignored when determining version precedence. Thus two versions that differ only in the build metadata, have the same precedence.
10. A version number MUST be no longer than 255 characters, including extra version and build metadata.
11. Precedence refers to how versions are compared to each other when ordered.
    1. Precedence MUST be calculated by separating the version into major, minor, patch and extra identifiers in that order (Build metadata does not figure into precedence).
    2. Precedence is determined by the first difference when comparing each of these identifiers from left to right as follows: Major, minor, and patch versions are always compared numerically.
    3. When major, minor, and patch are equal, an extra version has lower precedence than a normal version.
    4. Precedence for two extra versions with the same major, minor, and patch version MUST be determined by comparing each dot separated identifier from left to right until a difference is found as follows:
       1. Identifiers consisting of only digits are compared numerically.
       2. Identifiers with letters or hyphens are compared lexically in ASCII sort order.
       3. Numeric identifiers always have lower precedence than non-numeric identifiers.
       4. A larger set of extra identifiers fields has a higher precedence than a smaller set, if all of the preceding identifiers are equal.
12. Select the subcategory below that best describes the artifact. They are ordered in descending priority, so pick the first category that matches your software type.

2.1. Version Classes

While the general meaning of a PATCH, MINOR, and MAJOR version are defined in the specification above the specific interpretation is not always clear depending on the class of resources you happen to be versioning. An API, Schema, or even an application would all interpret when to increment a version a bit differently. Therefore we have tried to define explicitly versioning rules for the various classes of resources of interest. Any class not covered in this specification is technically not covered by it, but it is still recommended that the general principles outlined in the specification above be adhered to when possible.

When an artifact covers several exposed components that are either of different versioning classes, or just make sense to version separately then they SHOULD always be versioned separately. The overall artifact version can be determined by the hybrid versioning class mentioned below.

2.1.1. API Versioning

When versioning software with a public API such as libraries, and web endpoints it MUST match the following criteria:

1. The resource MUST declare a public API.

2. The API MUST be declared as code or specification documentation.

For any artifact of this type the meaning of incrementing the components of a version are as follows:

• PATCH - An internal fix to bring behavior in compliance with the documented expected behavior for the public API; this SHOULD NOT implement changes to the public API signatures.

• MINOR -If new functionality is added to the public API in a backward compatible way, including new information in return values. k Additionally, if any public functionality is marked as deprecated, but remains available to maintain backward compatibility, the MINOR version MUST be incremented.

• MAJOR - Any change to the public API that breaks backward compatibility.

This specification guarantees backward compatibility with SemVer.org version 2.0 and only version 2.0. However, forward compatibility with future versions is not guaranteed. Implementers SHOULD ensure their systems are designed with this limitation in mind.

2.1.2. UI Versioning

When versioning User Interfaces which MAY have any nature of input whether it be command-line, GUI, or some other interface, the following paradigm SHOULD be used. The following criteria MUST be satisfied:

1. The resource MUST have a user interface of some kind, of which both command-line and GUI are acceptable.

For any artifact of this type the meaning of incrementing the components of a version are as follows:

• PATCH - An internal fix to bring behavior in compliance with the documented expected behavior for the UI; this SHOULD implement no changes to the user interface of any kind.

• MINOR - Any backward compatible changes to the UI. Backward compatible means while new entries and elements can be added the existing ones SHOULD retain their same name, exist somewhere within the same menu items and menu structure, and behave consistently as they have in the past (or fixed according to the documented and expected behavior). This applies to all language variants of the interface.

• MAJOR - Any change to any of the interface in any language, that breaks backward compatibility.

2.1.3. Dataset Versioning

When versioning datasets, the schema (see Schema Versioning below) MAY be versioned alongside the dataset or separately. A dataset MAY include such things as a RDBMS database, a Semantic Web Knowledge Graph, or an XML file. Such Datasets MUST describe the following:

1. Public structured data for which access is being provided.

For any artifact of this type the meaning of incrementing the components of a version are as follows:

• PATCH - Additional rows / instances have been added to your dataset. This MUST also be incremented when incremented on the schema.

• MINOR - Additional, backward compatible, information is provided about existing rows/individuals. This MUST increment when MINOR is incremented in the underlying schema.

• MAJOR - Non-backward compatible changes to the data or underlying schema. This MUST be incremented when MAJOR is incremented in the underlying schema.

2.1.4. Schema Versioning

When versioning schemas for reading or interacting with datasets—such as RDBMS Schemas, Semantic Web Ontologies, and XML Schemas—the schema MUST describe the following:

1. Public structured data whose schema is being defined.

2. You are versioning the schema independently of the dataset or you are versioning the schema and not the dataset.

For any artifact of this type the meaning of incrementing the components of a version are as follows:

• PATCH - Additional or improved validation, indexing, and other backward compatible improvements that do not introduce new data. Also data's structure and typing is unchanged except for bugs contrary to the documented expected behavior.

• MINOR - Additions only to the schema allowing access to new underlying data while not changing the structure of historical data.

• MAJOR - Any changes to the structure of the data preventing backward compatible access to historical data.

2.1.5. Hybrid Versioning

When versioning artifacts that contain multiple resources that SHOULD be versioned separately, which is required when you have public interfaces that represent two or more of the version classes listed here, then you MUST use hybrid versioning. To use Hybrid Versioning the following criteria MUST be met.

1. The artifact MUST include two or more publicly exposed components that can be defined by one of the versioning classes outlined here.

2. The exposed components MUST be of either different versioning classes, or are versioned separately.

When versioning an artifact with multiple hybrid versions each versioned public component receives an independent version according to the rules of its versioning class. In addition the overall artifact gets an additional version, this version will increment one of its parts depending on the most significant version change across all its other interfaces, incrementing at most one version step. The specific parts of the version behave as follows:

• META - This will be dropped or assigned at the package maintainers discretion. Never expect it to be an ordered value.

• EXTRA - Increment this when the most significant version change among your other components was an EXTRA version increase. This field MAY not reset when a higher position resets. It will always be, at a minimum, the lowest value, if any, after reset, from all its subcomponents.

• PATCH - Increment this when the most significant version change among your other components was a PATCH version increase.

• MINOR - Increment this when the most significant version change among your other components was a MINOR version increase.

• MAJOR - Increment this when the most significant version change among your other components was a MAJOR version increase.

2.2. Dependent Artifact Versioning

On occasion you have software that needs to be versioned relative to the to the version against which it is written. Example projects and schema-extensions are good examples of this. Such software SHOULD have the following criteria:

1. Its version only makes sense relative to the base projects version.

2. The version of the base project will always be treated as a more significant digit than the version of this project.

When using this versioning paradigm the EXTRA field is used to embed this projects encoding. The EXTRA field effectively embeds a second version that follows all the same rules as a standalone normal version. The fully expanded format for a version with this paradigm would now be MAJOR_BASE.MINOR_BASE.PATCH_BASE which expands to:

MAJOR_BASE.MINOR_BASE.PATCH_BASE-MAJOR.MINOR.PATCH+META_BASE

For any artifact of this type the meaning of incrementing the components of a version entirely depend on the versioning class itself.

    <valid semver> ::= <version core>
                     | <version core> "-" <extra>
                     | <version core> "+" <build>
                     | <version core> "-" <extra> "+" <build>
    
    <version core> ::= <major> "." <minor> "." <patch>
    <major> ::= <numeric identifier>
    <minor> ::= <numeric identifier>
    <patch> ::= <numeric identifier>
    <extra> ::= <dot-separated extra identifiers>
    <dot-separated extra identifiers> ::= <extra identifier>
                                              | <extra identifier> "." <dot-separated extra identifiers>
    <build> ::= <dot-separated build identifiers>
    <dot-separated build identifiers> ::= <build identifier>
                                        | <build identifier> "." <dot-separated build identifiers>
    <extra identifier> ::= <alphanumeric identifier>
                               | <numeric identifier>
    <build identifier> ::= <alphanumeric identifier>
                         | <digits>
    <alphanumeric identifier> ::= <non-digit>
                                | <non-digit> <identifier characters>
                                | <identifier characters> <non-digit>
                                | <identifier characters> <non-digit> <identifier characters>
    <numeric identifier> ::= "0"
                           | <positive digit>
                           | <positive digit> <digits>
    <identifier characters> ::= <identifier character>
                              | <identifier character> <identifier characters>
    <identifier character> ::= <digit>
                             | <non-digit>
    <non-digit> ::= <letter>
                  | "-"
    <digits> ::= <digit>
              | <digit> <digits>
    <digit> ::= "0"
             | <positive digit>
    <positive digit> ::= "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9"
    <letter> ::= "A" | "B" | "C" | "D" | "E" | "F" | "G" | "H" | "I" | "J"
              | "K" | "L" | "M" | "N" | "O" | "P" | "Q" | "R" | "S" | "T"
              | "U" | "V" | "W" | "X" | "Y" | "Z" | "a" | "b" | "c" | "d"
              | "e" | "f" | "g" | "h" | "i" | "j" | "k" | "l" | "m" | "n"
              | "o" | "p" | "q" | "r" | "s" | "t" | "u" | "v" | "w" | "x"
              | "y" | "z"