feat: Allow custom change types.

BREAKING CHANGE: `BumpType` renamed to `ChangeType` with many relevant renamings throughout other structs.

Author: dbanty

Cargo.lock

@@ -44,15 +44,15 @@ knope: minor
 This is a feature for Knope in the same PR
 ```
 
-When you release, the `knope` package would contain both summaries in its changelog (and apply the greatest bump type), and the `changesets` package would contain only the first summary in its changelog.
+When you release, the `knope` package would contain both summaries in its changelog (and bump the version based on the highest change type), and the `changesets` package would contain only the first summary in its changelog.
 
 This works very similarly to [conventional commits](https://www.conventionalcommits.org/en/v1.0.0/), but does not rely on Git. You can use this together _with_ conventional commits using a tool like [Knope].
 
 ## Terminology in this project
 
-- **Change**: A single Markdown file (usually in the `.changeset` directory) describing a change to one or more packages. Note that this matches the original definition of [changesets]. A change contains a summary (in Markdown), a list of packages affected, and the semver "bump type" for each package.
+- **Change**: A single Markdown file (usually in the `.changeset` directory) describing a change to one or more packages. Note that this matches the original definition of [changesets]. A change contains a summary (in Markdown), a list of packages affected, and the semver "change type" for each package.
 - **Change summary**: The Markdown description of a change. This is the body of the change file. It should be included in the generated changelog.
-- **Bump type**: One of `none`, `patch`, `minor`, or `major`, describing which components of a semantic version are affected by the change.
+- **Change type**: A string describing which type of change this is. If it is one of `patch`, `minor`, or `major`, the version will be bumped accordingly. All other types of changes will have no effect on the version, but may be used in the generation of the changelog.
 - **Package**: A releasable unit of code. Examples include a Rust crate, a JavaScript package, a Go module. A change can affect multiple packages.
 - **Changeset**: A _set_ of _changes_ which will be released together. Notably, this differs from the original definition of [changesets], which is does not have a term for the bundle of multiple changes. A changeset may affect any number of packages.
 - **Release**: The part of a changeset that applies to a single package and determines how that package is released.

README.md

@@ -2,10 +2,9 @@ use std::{
     error::Error,
     fmt::Display,
     path::{Path, PathBuf},
-    str::FromStr,
 };
 
-use crate::{BuildVersioningError, BumpType, BumpTypeParsingError, PackageName, Versioning};
+use crate::{BuildVersioningError, ChangeType, PackageName, Versioning};
 
 /// Represents a single [change](https://github.com/knope-dev/changesets#terminology) which is
 /// applicable to any number of packages.
@@ -73,10 +72,10 @@ impl Change {
                     .split_once(':')
                     .ok_or(ParsingError::InvalidFrontMatter)?;
                 let package_name = PackageName::from(parts.0.trim());
-                let bump_type = BumpType::from_str(parts.1.trim())?;
-                Ok((package_name, bump_type))
+                let change_type = ChangeType::from(parts.1.trim());
+                Ok((package_name, change_type))
             })
-            .collect::<Result<Vec<(String, BumpType)>, ParsingError>>()?;
+            .collect::<Result<Vec<(String, ChangeType)>, ParsingError>>()?;
         let versioning = Versioning::try_from_iter(versioning_iter)?;
         let mut lines = lines.skip(versioning.len());
         let end_front_matter = lines.next().ok_or(ParsingError::InvalidFrontMatter)?;
@@ -98,8 +97,8 @@ impl Change {
 impl Display for Change {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         writeln!(f, "---")?;
-        for (package_name, bump_type) in self.versioning.iter() {
-            writeln!(f, "{package_name}: {bump_type}")?;
+        for (package_name, change_type) in self.versioning.iter() {
+            writeln!(f, "{package_name}: {change_type}")?;
         }
         writeln!(f, "---")?;
         writeln!(f)?;
@@ -120,12 +119,6 @@ impl From<BuildVersioningError> for ParsingError {
     }
 }
 
-impl From<BumpTypeParsingError> for ParsingError {
-    fn from(err: BumpTypeParsingError) -> Self {
-        ParsingError::InvalidVersioning(err.into())
-    }
-}
-
 impl Display for ParsingError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {

src/change.rs

@@ -1,6 +1,6 @@
 use std::{collections::HashMap, path::Path};
 
-use crate::{change::LoadingError, BumpType, Change, PackageName};
+use crate::{change::LoadingError, Change, ChangeType, PackageName};
 
 /// A set of [`Change`]s that combine to form [`Release`]s of one or more packages.
 #[derive(Clone, Debug, Eq, PartialEq)]
@@ -41,15 +41,15 @@ impl FromIterator<Change> for ChangeSet {
     fn from_iter<T: IntoIterator<Item = Change>>(iter: T) -> Self {
         let mut releases = HashMap::new();
         for change in iter {
-            for (package_name, bump_type) in change.versioning {
+            for (package_name, change_type) in change.versioning {
                 let release = releases
                     .entry(package_name.clone())
                     .or_insert_with(|| Release {
                         package_name,
                         changes: Vec::new(),
                     });
                 release.changes.push(PackageChange {
-                    bump_type,
+                    change_type,
                     summary: change.summary.clone(),
                 });
             }
@@ -66,22 +66,18 @@ pub struct Release {
 }
 
 impl Release {
-    /// The overall bump type for the package's version based on all the [`Release::changes`].
+    /// The overall [`ChangeType`] for the package's version based on all the [`Release::changes`].
     #[must_use]
-    pub fn bump_type(&self) -> BumpType {
-        self.changes
-            .iter()
-            .map(|change| change.bump_type)
-            .max()
-            .unwrap_or_default()
+    pub fn change_type(&self) -> Option<&ChangeType> {
+        self.changes.iter().map(|change| &change.change_type).max()
     }
 }
 
 /// A [`Change`] as it applies to a single package for a [`Release`],
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub struct PackageChange {
-    /// The type of bump to apply to the package's version.
-    pub bump_type: BumpType,
+    /// The type of change, which determines how the version will be bumped (if at all).
+    pub change_type: ChangeType,
     /// The details of the change, as a markdown-formatted string.
     pub summary: String,
 }

src/changeset.rs

@@ -20,9 +20,7 @@
 
 pub use change::{Change, LoadingError as ChangeParsingError, ParsingError as ChangeLoadingError};
 pub use changeset::{ChangeSet, PackageChange, Release};
-pub use versioning::{
-    BuildVersioningError, BumpType, BumpTypeParsingError, PackageName, Versioning,
-};
+pub use versioning::{BuildVersioningError, ChangeType, PackageName, Versioning};
 
 mod change;
 mod changeset;

src/lib.rs

@@ -4,24 +4,23 @@ use std::{
     convert::Infallible,
     error::Error,
     fmt::{Display, Formatter},
-    str::FromStr,
 };
 
 /// Describes how a [`crate::Change`] affects the version of relevant packages.
 ///
 /// This is guaranteed to never be empty, as a changeset must always apply to at least one package.
 #[derive(Clone, Debug, Eq, PartialEq)]
-pub struct Versioning(HashMap<PackageName, BumpType>);
+pub struct Versioning(HashMap<PackageName, ChangeType>);
 
-impl From<(&str, BumpType)> for Versioning {
-    fn from(value: (&str, BumpType)) -> Self {
+impl From<(&str, ChangeType)> for Versioning {
+    fn from(value: (&str, ChangeType)) -> Self {
         let value = (PackageName::from(value.0), value.1);
         Self::from(value)
     }
 }
 
-impl From<(PackageName, BumpType)> for Versioning {
-    fn from(value: (PackageName, BumpType)) -> Self {
+impl From<(PackageName, ChangeType)> for Versioning {
+    fn from(value: (PackageName, ChangeType)) -> Self {
         let mut map = HashMap::new();
         map.insert(value.0, value.1);
         Self(map)
@@ -33,14 +32,13 @@ impl Versioning {
     ///
     /// # Errors
     ///
-    /// 1. If the values type cannot be converted into a [`BumpType`], you'll get [`BuildVersioningError::BumpTypeParsingError`].
-    /// 2. If the iterator is empty, you'll get [`BuildVersioningError::EmptyVersioningError`].
+    /// 1. If the iterator is empty, you'll get [`BuildVersioningError::EmptyVersioningError`].
     pub fn try_from_iter<Key, Value, ParseError, Iter>(
         iter: Iter,
     ) -> Result<Self, BuildVersioningError>
     where
         Key: Into<PackageName>,
-        Value: TryInto<BumpType, Error = ParseError>,
+        Value: TryInto<ChangeType, Error = ParseError>,
         ParseError: Into<BuildVersioningError>,
         Iter: IntoIterator<Item = (Key, Value)>,
     {
@@ -52,15 +50,15 @@ impl Versioning {
                     .map_err(Into::into)
                     .map(|value| (key.into(), value))
             })
-            .collect::<Result<HashMap<PackageName, BumpType>, BuildVersioningError>>()?;
+            .collect::<Result<HashMap<PackageName, ChangeType>, BuildVersioningError>>()?;
         if map.is_empty() {
             Err(BuildVersioningError::EmptyVersioningError)
         } else {
             Ok(Self(map))
         }
     }
 
-    pub fn iter(&self) -> impl Iterator<Item = (&PackageName, &BumpType)> {
+    pub fn iter(&self) -> impl Iterator<Item = (&PackageName, &ChangeType)> {
         self.0.iter()
     }
 
@@ -76,21 +74,19 @@ impl Versioning {
 }
 
 impl IntoIterator for Versioning {
-    type Item = (PackageName, BumpType);
-    type IntoIter = std::collections::hash_map::IntoIter<PackageName, BumpType>;
+    type Item = (PackageName, ChangeType);
+    type IntoIter = std::collections::hash_map::IntoIter<PackageName, ChangeType>;
 
     fn into_iter(self) -> Self::IntoIter {
         self.0.into_iter()
     }
 }
 
 /// The error that occurs if you try to create a [`Versioning`] out of an iterator which has no items.
-#[derive(Debug)]
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
 pub enum BuildVersioningError {
     /// The iterator was empty.
     EmptyVersioningError,
-    /// The iterator contained an invalid [`BumpType`].
-    BumpTypeParsingError(BumpTypeParsingError),
 }
 
 impl Display for BuildVersioningError {
@@ -99,17 +95,10 @@ impl Display for BuildVersioningError {
             Self::EmptyVersioningError => {
                 f.write_str("Versioning needs to contain at least one item.")
             }
-            Self::BumpTypeParsingError(error) => error.fmt(f),
         }
     }
 }
 
-impl From<BumpTypeParsingError> for BuildVersioningError {
-    fn from(value: BumpTypeParsingError) -> Self {
-        Self::BumpTypeParsingError(value)
-    }
-}
-
 impl From<Infallible> for BuildVersioningError {
     fn from(_: Infallible) -> Self {
         unreachable!()
@@ -123,71 +112,55 @@ pub type PackageName = String;
 
 /// The [Semantic Versioning](https://semver.org/) component which should be incremented when a [`Change`]
 /// is applied.
-#[derive(Copy, Clone, Debug, Default, Eq, PartialEq)]
-pub enum BumpType {
-    #[default]
-    None,
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub enum ChangeType {
     Patch,
     Minor,
     Major,
+    Custom(String),
 }
 
-impl Display for BumpType {
+impl Display for ChangeType {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         match self {
-            BumpType::None => write!(f, "none"),
-            BumpType::Patch => write!(f, "patch"),
-            BumpType::Minor => write!(f, "minor"),
-            BumpType::Major => write!(f, "major"),
+            ChangeType::Custom(label) => write!(f, "{label}"),
+            ChangeType::Patch => write!(f, "patch"),
+            ChangeType::Minor => write!(f, "minor"),
+            ChangeType::Major => write!(f, "major"),
         }
     }
 }
 
-impl FromStr for BumpType {
-    type Err = BumpTypeParsingError;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
+impl From<&str> for ChangeType {
+    fn from(s: &str) -> Self {
         match s {
-            "none" => Ok(BumpType::None),
-            "patch" => Ok(BumpType::Patch),
-            "minor" => Ok(BumpType::Minor),
-            "major" => Ok(BumpType::Major),
-            _ => Err(BumpTypeParsingError(String::from(s))),
+            "patch" => ChangeType::Patch,
+            "minor" => ChangeType::Minor,
+            "major" => ChangeType::Major,
+            other => ChangeType::Custom(other.to_string()),
         }
     }
 }
 
-impl Ord for BumpType {
+impl Ord for ChangeType {
     fn cmp(&self, other: &Self) -> Ordering {
         match (self, other) {
-            (BumpType::None, BumpType::None)
-            | (BumpType::Major, BumpType::Major)
-            | (BumpType::Patch, BumpType::Patch)
-            | (BumpType::Minor, BumpType::Minor) => Ordering::Equal,
-            (BumpType::None, _) => Ordering::Less,
-            (_, BumpType::None) => Ordering::Greater,
-            (BumpType::Patch, _) => Ordering::Less,
-            (_, BumpType::Patch) => Ordering::Greater,
-            (BumpType::Minor, _) => Ordering::Less,
-            (_, BumpType::Minor) => Ordering::Greater,
+            (ChangeType::Custom(_), ChangeType::Custom(_))
+            | (ChangeType::Major, ChangeType::Major)
+            | (ChangeType::Patch, ChangeType::Patch)
+            | (ChangeType::Minor, ChangeType::Minor) => Ordering::Equal,
+            (ChangeType::Custom(_), _) => Ordering::Less,
+            (_, ChangeType::Custom(_)) => Ordering::Greater,
+            (ChangeType::Patch, _) => Ordering::Less,
+            (_, ChangeType::Patch) => Ordering::Greater,
+            (ChangeType::Minor, _) => Ordering::Less,
+            (_, ChangeType::Minor) => Ordering::Greater,
         }
     }
 }
 
-impl PartialOrd for BumpType {
+impl PartialOrd for ChangeType {
     fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
         Some(self.cmp(other))
     }
 }
-
-/// The error that occurs when [`BumpType::from_str`] fails due to an invalid input.
-#[derive(Debug)]
-pub struct BumpTypeParsingError(String);
-
-impl Display for BumpTypeParsingError {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{} is not a valid BumpType", self.0)
-    }
-}
-
-impl Error for BumpTypeParsingError {}

src/versioning.rs

@@ -1,19 +1,19 @@
-use changesets::{BumpType, Change, Versioning};
+use changesets::{Change, ChangeType, Versioning};
 use tempfile::tempdir;
 
 #[test]
 fn create_change() {
     let basic_programmatic = Change {
         unique_id: String::from("basic_programmatic"),
-        versioning: Versioning::from(("my_package", BumpType::Minor)),
+        versioning: Versioning::from(("my_package", ChangeType::Minor)),
         summary: String::from("### This is a summary"),
     };
 
     let multiple_packages = Change {
         unique_id: String::from("multiple_packages"),
         versioning: Versioning::try_from_iter([
-            ("my_package", BumpType::Minor),
-            ("my_other_package", BumpType::Major),
+            ("my_package", ChangeType::Minor),
+            ("my_other_package", ChangeType::Major),
         ])
         .unwrap(),
         summary: String::from("### This is a summary"),
@@ -58,6 +58,6 @@ fn load_change() {
     assert_eq!(change.summary, "### This is a summary");
     assert_eq!(
         change.versioning,
-        Versioning::from(("my_package", BumpType::Minor))
+        Versioning::from(("my_package", ChangeType::Minor))
     );
 }