diff --git a/.github/actions/run-fixtures-test/action.yml b/.github/actions/run-fixtures-test/action.yml
index ad9774b1cb..5839612041 100644
--- a/.github/actions/run-fixtures-test/action.yml
+++ b/.github/actions/run-fixtures-test/action.yml
@@ -18,7 +18,7 @@ runs:
   using: composite
   steps:
     - name: Install toolchain
-      uses: dtolnay/rust-toolchain@nightly
+      uses: dtolnay/rust-toolchain@stable
 
     - name: Install git-cliff
       run: cargo install --path git-cliff/ --profile dev
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index cd55987c1b..93fd733d7e 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -47,7 +47,7 @@ jobs:
     runs-on: ubuntu-22.04
     steps:
       - name: Install toolchain
-        uses: dtolnay/rust-toolchain@nightly
+        uses: dtolnay/rust-toolchain@stable
       - name: Checkout
         if: github.event_name != 'pull_request'
         uses: actions/checkout@v4
@@ -84,7 +84,7 @@ jobs:
     runs-on: ubuntu-22.04
     steps:
       - name: Install toolchain
-        uses: dtolnay/rust-toolchain@nightly
+        uses: dtolnay/rust-toolchain@stable
         with:
           components: clippy
       - name: Checkout
@@ -123,7 +123,7 @@ jobs:
     runs-on: ubuntu-22.04
     steps:
       - name: Install toolchain
-        uses: dtolnay/rust-toolchain@nightly
+        uses: dtolnay/rust-toolchain@stable
         with:
           components: rustfmt
       - name: Checkout
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 3812f70ec8..cbc8d423d3 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -45,8 +45,6 @@ env UPDATE_EXPECT=1 cargo test
 
 7. Make sure [rustfmt](https://github.com/rust-lang/rustfmt) and [clippy](https://github.com/rust-lang/rust-clippy) don't complain about your changes.
 
-We use the `nightly` channel for `rustfmt` so please set the appropriate settings for your editor/IDE for that.
-
 ## Create a Pull Request
 
 1. Ensure that you updated the documentation and filled the [Pull Request template](./.github/PULL_REQUEST_TEMPLATE.md) according to the changes you made.
diff --git a/git-cliff-core/src/changelog.rs b/git-cliff-core/src/changelog.rs
index a505a127a5..a53abc8b23 100644
--- a/git-cliff-core/src/changelog.rs
+++ b/git-cliff-core/src/changelog.rs
@@ -1,13 +1,7 @@
 use crate::commit::Commit;
-use crate::config::{
-	Config,
-	GitConfig,
-};
+use crate::config::{Config, GitConfig};
 use crate::error::Result;
-use crate::release::{
-	Release,
-	Releases,
-};
+use crate::release::{Release, Releases};
 #[cfg(feature = "bitbucket")]
 use crate::remote::bitbucket::BitbucketClient;
 #[cfg(feature = "gitea")]
@@ -18,644 +12,600 @@ use crate::remote::github::GitHubClient;
 use crate::remote::gitlab::GitLabClient;
 use crate::template::Template;
 use std::collections::HashMap;
-use std::io::{
-	Read,
-	Write,
-};
-use std::time::{
-	SystemTime,
-	UNIX_EPOCH,
-};
+use std::io::{Read, Write};
+use std::time::{SystemTime, UNIX_EPOCH};
 
 /// Changelog generator.
 #[derive(Debug)]
 pub struct Changelog<'a> {
-	/// Releases that the changelog will contain.
-	pub releases:       Vec<Release<'a>>,
-	header_template:    Option<Template>,
-	body_template:      Template,
-	footer_template:    Option<Template>,
-	config:             &'a Config,
-	additional_context: HashMap<String, serde_json::Value>,
+    /// Releases that the changelog will contain.
+    pub releases: Vec<Release<'a>>,
+    header_template: Option<Template>,
+    body_template: Template,
+    footer_template: Option<Template>,
+    config: &'a Config,
+    additional_context: HashMap<String, serde_json::Value>,
 }
 
 impl<'a> Changelog<'a> {
-	/// Constructs a new instance.
-	pub fn new(releases: Vec<Release<'a>>, config: &'a Config) -> Result<Self> {
-		let mut changelog = Changelog::build(releases, config)?;
-		changelog.add_remote_data()?;
-		changelog.process_commits();
-		changelog.process_releases();
-		Ok(changelog)
-	}
-
-	/// Builds a changelog from releases and config.
-	fn build(releases: Vec<Release<'a>>, config: &'a Config) -> Result<Self> {
-		let trim = config.changelog.trim.unwrap_or(true);
-		Ok(Self {
-			releases,
-			header_template: match &config.changelog.header {
-				Some(header) => {
-					Some(Template::new("header", header.to_string(), trim)?)
-				}
-				None => None,
-			},
-			body_template: get_body_template(config, trim)?,
-			footer_template: match &config.changelog.footer {
-				Some(footer) => {
-					Some(Template::new("footer", footer.to_string(), trim)?)
-				}
-				None => None,
-			},
-			config,
-			additional_context: HashMap::new(),
-		})
-	}
-
-	/// Constructs an instance from a serialized context object.
-	pub fn from_context<R: Read>(input: &mut R, config: &'a Config) -> Result<Self> {
-		Changelog::build(serde_json::from_reader(input)?, config)
-	}
-
-	/// Adds a key value pair to the template context.
-	///
-	/// These values will be used when generating the changelog.
-	///
-	/// # Errors
-	///
-	/// This operation fails if the deserialization fails.
-	pub fn add_context(
-		&mut self,
-		key: impl Into<String>,
-		value: impl serde::Serialize,
-	) -> Result<()> {
-		self.additional_context
-			.insert(key.into(), serde_json::to_value(value)?);
-		Ok(())
-	}
-
-	/// Processes a single commit and returns/logs the result.
-	fn process_commit(
-		commit: &Commit<'a>,
-		git_config: &GitConfig,
-	) -> Option<Commit<'a>> {
-		match commit.process(git_config) {
-			Ok(commit) => Some(commit),
-			Err(e) => {
-				trace!(
-					"{} - {} ({})",
-					commit.id[..7].to_string(),
-					e,
-					commit.message.lines().next().unwrap_or_default().trim()
-				);
-				None
-			}
-		}
-	}
-
-	/// Processes the commits and omits the ones that doesn't match the
-	/// criteria set by configuration file.
-	fn process_commits(&mut self) {
-		debug!("Processing the commits...");
-		self.releases.iter_mut().for_each(|release| {
-			release.commits = release
-				.commits
-				.iter()
-				.cloned()
-				.filter_map(|commit| Self::process_commit(&commit, &self.config.git))
-				.flat_map(|commit| {
-					if self.config.git.split_commits.unwrap_or(false) {
-						commit
-							.message
-							.lines()
-							.filter_map(|line| {
-								let mut c = commit.clone();
-								c.message = line.to_string();
-								if c.message.is_empty() {
-									None
-								} else {
-									Self::process_commit(&c, &self.config.git)
-								}
-							})
-							.collect()
-					} else {
-						vec![commit]
-					}
-				})
-				.collect::<Vec<Commit>>();
-		});
-	}
-
-	/// Processes the releases and filters them out based on the configuration.
-	fn process_releases(&mut self) {
-		debug!("Processing {} release(s)...", self.releases.len());
-		let skip_regex = self.config.git.skip_tags.as_ref();
-		let mut skipped_tags = Vec::new();
-		self.releases = self
-			.releases
-			.clone()
-			.into_iter()
-			.rev()
-			.filter(|release| {
-				if release.commits.is_empty() {
-					if let Some(version) = release.version.clone() {
-						trace!("Release doesn't have any commits: {}", version);
-					}
-					match &release.previous {
-						Some(prev_release) if prev_release.commits.is_empty() => {
-							self.config.changelog.render_always.unwrap_or(false)
-						}
-						_ => false,
-					}
-				} else if let Some(version) = &release.version {
-					!skip_regex.is_some_and(|r| {
-						let skip_tag = r.is_match(version);
-						if skip_tag {
-							skipped_tags.push(version.clone());
-							trace!("Skipping release: {}", version);
-						}
-						skip_tag
-					})
-				} else {
-					true
-				}
-			})
-			.collect();
-		for skipped_tag in &skipped_tags {
-			if let Some(release_index) = self.releases.iter().position(|release| {
-				release
-					.previous
-					.as_ref()
-					.and_then(|release| release.version.as_ref()) ==
-					Some(skipped_tag)
-			}) {
-				if let Some(previous_release) =
-					self.releases.get_mut(release_index + 1)
-				{
-					previous_release.previous = None;
-					self.releases[release_index].previous =
-						Some(Box::new(previous_release.clone()));
-				} else if release_index == self.releases.len() - 1 {
-					self.releases[release_index].previous = None;
-				}
-			}
-		}
-	}
-
-	/// Returns the GitHub metadata needed for the changelog.
-	///
-	/// This function creates a multithread async runtime for handling the
-	/// requests. The following are fetched from the GitHub REST API:
-	///
-	/// - Commits
-	/// - Pull requests
-	///
-	/// Each of these are paginated requests so they are being run in parallel
-	/// for speedup.
-	///
-	/// If no GitHub related variable is used in the template then this function
-	/// returns empty vectors.
-	#[cfg(feature = "github")]
-	fn get_github_metadata(&self) -> Result<crate::remote::RemoteMetadata> {
-		use crate::remote::github;
-		if self.config.remote.github.is_custom ||
-			self.body_template
-				.contains_variable(github::TEMPLATE_VARIABLES) ||
-			self.footer_template
-				.as_ref()
-				.map(|v| v.contains_variable(github::TEMPLATE_VARIABLES))
-				.unwrap_or(false)
-		{
-			warn!("You are using an experimental feature! Please report bugs at <https://git-cliff.org/issues>");
-			let github_client =
-				GitHubClient::try_from(self.config.remote.github.clone())?;
-			info!(
-				"{} ({})",
-				github::START_FETCHING_MSG,
-				self.config.remote.github
-			);
-			let data = tokio::runtime::Builder::new_multi_thread()
-				.enable_all()
-				.build()?
-				.block_on(async {
-					let (commits, pull_requests) = tokio::try_join!(
-						github_client.get_commits(),
-						github_client.get_pull_requests(),
-					)?;
-					debug!("Number of GitHub commits: {}", commits.len());
-					debug!(
-						"Number of GitHub pull requests: {}",
-						pull_requests.len()
-					);
-					Ok((commits, pull_requests))
-				});
-			info!("{}", github::FINISHED_FETCHING_MSG);
-			data
-		} else {
-			Ok((vec![], vec![]))
-		}
-	}
-
-	/// Returns the GitLab metadata needed for the changelog.
-	///
-	/// This function creates a multithread async runtime for handling the
-	///
-	/// requests. The following are fetched from the GitLab REST API:
-	///
-	/// - Commits
-	/// - Marge requests
-	///
-	/// Each of these are paginated requests so they are being run in parallel
-	/// for speedup.
-	///
-	///
-	/// If no GitLab related variable is used in the template then this function
-	/// returns empty vectors.
-	#[cfg(feature = "gitlab")]
-	fn get_gitlab_metadata(&self) -> Result<crate::remote::RemoteMetadata> {
-		use crate::remote::gitlab;
-		if self.config.remote.gitlab.is_custom ||
-			self.body_template
-				.contains_variable(gitlab::TEMPLATE_VARIABLES) ||
-			self.footer_template
-				.as_ref()
-				.map(|v| v.contains_variable(gitlab::TEMPLATE_VARIABLES))
-				.unwrap_or(false)
-		{
-			warn!("You are using an experimental feature! Please report bugs at <https://git-cliff.org/issues>");
-			let gitlab_client =
-				GitLabClient::try_from(self.config.remote.gitlab.clone())?;
-			info!(
-				"{} ({})",
-				gitlab::START_FETCHING_MSG,
-				self.config.remote.gitlab
-			);
-			let data = tokio::runtime::Builder::new_multi_thread()
-				.enable_all()
-				.build()?
-				.block_on(async {
-					// Map repo/owner to gitlab id
-					let project_id = match tokio::join!(gitlab_client.get_project())
-					{
-						(Ok(project),) => project.id,
-						(Err(err),) => {
-							error!("Failed to lookup project! {}", err);
-							return Err(err);
-						}
-					};
-					let (commits, merge_requests) = tokio::try_join!(
-						// Send id to these functions
-						gitlab_client.get_commits(project_id),
-						gitlab_client.get_merge_requests(project_id),
-					)?;
-					debug!("Number of GitLab commits: {}", commits.len());
-					debug!(
-						"Number of GitLab merge requests: {}",
-						merge_requests.len()
-					);
-					Ok((commits, merge_requests))
-				});
-			info!("{}", gitlab::FINISHED_FETCHING_MSG);
-			data
-		} else {
-			Ok((vec![], vec![]))
-		}
-	}
-
-	/// Returns the Gitea metadata needed for the changelog.
-	///
-	/// This function creates a multithread async runtime for handling the
-	/// requests. The following are fetched from the GitHub REST API:
-	///
-	/// - Commits
-	/// - Pull requests
-	///
-	/// Each of these are paginated requests so they are being run in parallel
-	/// for speedup.
-	///
-	/// If no Gitea related variable is used in the template then this function
-	/// returns empty vectors.
-	#[cfg(feature = "gitea")]
-	fn get_gitea_metadata(&self) -> Result<crate::remote::RemoteMetadata> {
-		use crate::remote::gitea;
-		if self.config.remote.gitea.is_custom ||
-			self.body_template
-				.contains_variable(gitea::TEMPLATE_VARIABLES) ||
-			self.footer_template
-				.as_ref()
-				.map(|v| v.contains_variable(gitea::TEMPLATE_VARIABLES))
-				.unwrap_or(false)
-		{
-			warn!("You are using an experimental feature! Please report bugs at <https://git-cliff.org/issues>");
-			let gitea_client =
-				GiteaClient::try_from(self.config.remote.gitea.clone())?;
-			info!(
-				"{} ({})",
-				gitea::START_FETCHING_MSG,
-				self.config.remote.gitea
-			);
-			let data = tokio::runtime::Builder::new_multi_thread()
-				.enable_all()
-				.build()?
-				.block_on(async {
-					let (commits, pull_requests) = tokio::try_join!(
-						gitea_client.get_commits(),
-						gitea_client.get_pull_requests(),
-					)?;
-					debug!("Number of Gitea commits: {}", commits.len());
-					debug!("Number of Gitea pull requests: {}", pull_requests.len());
-					Ok((commits, pull_requests))
-				});
-			info!("{}", gitea::FINISHED_FETCHING_MSG);
-			data
-		} else {
-			Ok((vec![], vec![]))
-		}
-	}
-
-	/// Returns the Bitbucket metadata needed for the changelog.
-	///
-	/// This function creates a multithread async runtime for handling the
-	///
-	/// requests. The following are fetched from the bitbucket REST API:
-	///
-	/// - Commits
-	/// - Pull requests
-	///
-	/// Each of these are paginated requests so they are being run in parallel
-	/// for speedup.
-	///
-	///
-	/// If no bitbucket related variable is used in the template then this
-	/// function returns empty vectors.
-	#[cfg(feature = "bitbucket")]
-	fn get_bitbucket_metadata(&self) -> Result<crate::remote::RemoteMetadata> {
-		use crate::remote::bitbucket;
-		if self.config.remote.bitbucket.is_custom ||
-			self.body_template
-				.contains_variable(bitbucket::TEMPLATE_VARIABLES) ||
-			self.footer_template
-				.as_ref()
-				.map(|v| v.contains_variable(bitbucket::TEMPLATE_VARIABLES))
-				.unwrap_or(false)
-		{
-			warn!("You are using an experimental feature! Please report bugs at <https://git-cliff.org/issues>");
-			let bitbucket_client =
-				BitbucketClient::try_from(self.config.remote.bitbucket.clone())?;
-			info!(
-				"{} ({})",
-				bitbucket::START_FETCHING_MSG,
-				self.config.remote.bitbucket
-			);
-			let data = tokio::runtime::Builder::new_multi_thread()
-				.enable_all()
-				.build()?
-				.block_on(async {
-					let (commits, pull_requests) = tokio::try_join!(
-						bitbucket_client.get_commits(),
-						bitbucket_client.get_pull_requests()
-					)?;
-					debug!("Number of Bitbucket commits: {}", commits.len());
-					debug!(
-						"Number of Bitbucket pull requests: {}",
-						pull_requests.len()
-					);
-					Ok((commits, pull_requests))
-				});
-			info!("{}", bitbucket::FINISHED_FETCHING_MSG);
-			data
-		} else {
-			Ok((vec![], vec![]))
-		}
-	}
-
-	/// Adds information about the remote to the template context.
-	pub fn add_remote_context(&mut self) -> Result<()> {
-		self.additional_context.insert(
-			"remote".to_string(),
-			serde_json::to_value(self.config.remote.clone())?,
-		);
-		Ok(())
-	}
-
-	/// Adds remote data (e.g. GitHub commits) to the releases.
-	pub fn add_remote_data(&mut self) -> Result<()> {
-		debug!("Adding remote data...");
-		self.add_remote_context()?;
-
-		#[cfg(feature = "github")]
-		let (github_commits, github_pull_requests) = if self.config.remote.github.is_set()
-		{
-			self.get_github_metadata()
-				.expect("Could not get github metadata")
-		} else {
-			(vec![], vec![])
-		};
-		#[cfg(feature = "gitlab")]
-		let (gitlab_commits, gitlab_merge_request) = if self.config.remote.gitlab.is_set()
-		{
-			self.get_gitlab_metadata()
-				.expect("Could not get gitlab metadata")
-		} else {
-			(vec![], vec![])
-		};
-		#[cfg(feature = "gitea")]
-		let (gitea_commits, gitea_merge_request) = if self.config.remote.gitea.is_set() {
-			self.get_gitea_metadata()
-				.expect("Could not get gitea metadata")
-		} else {
-			(vec![], vec![])
-		};
-		#[cfg(feature = "bitbucket")]
-		let (bitbucket_commits, bitbucket_pull_request) =
-			if self.config.remote.bitbucket.is_set() {
-				self.get_bitbucket_metadata()
-					.expect("Could not get bitbucket metadata")
-			} else {
-				(vec![], vec![])
-			};
-		#[cfg(feature = "remote")]
-		for release in &mut self.releases {
-			#[cfg(feature = "github")]
-			release.update_github_metadata(
-				github_commits.clone(),
-				github_pull_requests.clone(),
-			)?;
-			#[cfg(feature = "gitlab")]
-			release.update_gitlab_metadata(
-				gitlab_commits.clone(),
-				gitlab_merge_request.clone(),
-			)?;
-			#[cfg(feature = "gitea")]
-			release.update_gitea_metadata(
-				gitea_commits.clone(),
-				gitea_merge_request.clone(),
-			)?;
-			#[cfg(feature = "bitbucket")]
-			release.update_bitbucket_metadata(
-				bitbucket_commits.clone(),
-				bitbucket_pull_request.clone(),
-			)?;
-		}
-		Ok(())
-	}
-
-	/// Increments the version for the unreleased changes based on semver.
-	pub fn bump_version(&mut self) -> Result<Option<String>> {
-		if let Some(ref mut last_release) = self.releases.iter_mut().next() {
-			if last_release.version.is_none() {
-				let next_version = last_release
-					.calculate_next_version_with_config(&self.config.bump)?;
-				debug!("Bumping the version to {next_version}");
-				last_release.version = Some(next_version.to_string());
-				last_release.timestamp = SystemTime::now()
-					.duration_since(UNIX_EPOCH)?
-					.as_secs()
-					.try_into()?;
-				return Ok(Some(next_version));
-			}
-		}
-		Ok(None)
-	}
-
-	/// Generates the changelog and writes it to the given output.
-	pub fn generate<W: Write + ?Sized>(&self, out: &mut W) -> Result<()> {
-		debug!("Generating changelog...");
-		let postprocessors = self
-			.config
-			.changelog
-			.postprocessors
-			.clone()
-			.unwrap_or_default();
-
-		if let Some(header_template) = &self.header_template {
-			let write_result = writeln!(
-				out,
-				"{}",
-				header_template.render(
-					&Releases {
-						releases: &self.releases,
-					},
-					Some(&self.additional_context),
-					&postprocessors,
-				)?
-			);
-			if let Err(e) = write_result {
-				if e.kind() != std::io::ErrorKind::BrokenPipe {
-					return Err(e.into());
-				}
-			}
-		}
-
-		for release in &self.releases {
-			let write_result = write!(
-				out,
-				"{}",
-				self.body_template.render(
-					&release,
-					Some(&self.additional_context),
-					&postprocessors
-				)?
-			);
-			if let Err(e) = write_result {
-				if e.kind() != std::io::ErrorKind::BrokenPipe {
-					return Err(e.into());
-				}
-			}
-		}
-
-		if let Some(footer_template) = &self.footer_template {
-			let write_result = writeln!(
-				out,
-				"{}",
-				footer_template.render(
-					&Releases {
-						releases: &self.releases,
-					},
-					Some(&self.additional_context),
-					&postprocessors,
-				)?
-			);
-			if let Err(e) = write_result {
-				if e.kind() != std::io::ErrorKind::BrokenPipe {
-					return Err(e.into());
-				}
-			}
-		}
-
-		Ok(())
-	}
-
-	/// Generates a changelog and prepends it to the given changelog.
-	pub fn prepend<W: Write + ?Sized>(
-		&self,
-		mut changelog: String,
-		out: &mut W,
-	) -> Result<()> {
-		debug!("Generating changelog and prepending...");
-		if let Some(header) = &self.config.changelog.header {
-			changelog = changelog.replacen(header, "", 1);
-		}
-		self.generate(out)?;
-		write!(out, "{changelog}")?;
-		Ok(())
-	}
-
-	/// Prints the changelog context to the given output.
-	pub fn write_context<W: Write + ?Sized>(&self, out: &mut W) -> Result<()> {
-		let output = Releases {
-			releases: &self.releases,
-		}
-		.as_json()?;
-		writeln!(out, "{output}")?;
-		Ok(())
-	}
+    /// Constructs a new instance.
+    pub fn new(releases: Vec<Release<'a>>, config: &'a Config) -> Result<Self> {
+        let mut changelog = Changelog::build(releases, config)?;
+        changelog.add_remote_data()?;
+        changelog.process_commits();
+        changelog.process_releases();
+        Ok(changelog)
+    }
+
+    /// Builds a changelog from releases and config.
+    fn build(releases: Vec<Release<'a>>, config: &'a Config) -> Result<Self> {
+        let trim = config.changelog.trim.unwrap_or(true);
+        Ok(Self {
+            releases,
+            header_template: match &config.changelog.header {
+                Some(header) => Some(Template::new("header", header.to_string(), trim)?),
+                None => None,
+            },
+            body_template: get_body_template(config, trim)?,
+            footer_template: match &config.changelog.footer {
+                Some(footer) => Some(Template::new("footer", footer.to_string(), trim)?),
+                None => None,
+            },
+            config,
+            additional_context: HashMap::new(),
+        })
+    }
+
+    /// Constructs an instance from a serialized context object.
+    pub fn from_context<R: Read>(input: &mut R, config: &'a Config) -> Result<Self> {
+        Changelog::build(serde_json::from_reader(input)?, config)
+    }
+
+    /// Adds a key value pair to the template context.
+    ///
+    /// These values will be used when generating the changelog.
+    ///
+    /// # Errors
+    ///
+    /// This operation fails if the deserialization fails.
+    pub fn add_context(
+        &mut self,
+        key: impl Into<String>,
+        value: impl serde::Serialize,
+    ) -> Result<()> {
+        self.additional_context
+            .insert(key.into(), serde_json::to_value(value)?);
+        Ok(())
+    }
+
+    /// Processes a single commit and returns/logs the result.
+    fn process_commit(commit: &Commit<'a>, git_config: &GitConfig) -> Option<Commit<'a>> {
+        match commit.process(git_config) {
+            Ok(commit) => Some(commit),
+            Err(e) => {
+                trace!(
+                    "{} - {} ({})",
+                    commit.id[..7].to_string(),
+                    e,
+                    commit.message.lines().next().unwrap_or_default().trim()
+                );
+                None
+            }
+        }
+    }
+
+    /// Processes the commits and omits the ones that doesn't match the
+    /// criteria set by configuration file.
+    fn process_commits(&mut self) {
+        debug!("Processing the commits...");
+        self.releases.iter_mut().for_each(|release| {
+            release.commits = release
+                .commits
+                .iter()
+                .cloned()
+                .filter_map(|commit| Self::process_commit(&commit, &self.config.git))
+                .flat_map(|commit| {
+                    if self.config.git.split_commits.unwrap_or(false) {
+                        commit
+                            .message
+                            .lines()
+                            .filter_map(|line| {
+                                let mut c = commit.clone();
+                                c.message = line.to_string();
+                                if c.message.is_empty() {
+                                    None
+                                } else {
+                                    Self::process_commit(&c, &self.config.git)
+                                }
+                            })
+                            .collect()
+                    } else {
+                        vec![commit]
+                    }
+                })
+                .collect::<Vec<Commit>>();
+        });
+    }
+
+    /// Processes the releases and filters them out based on the configuration.
+    fn process_releases(&mut self) {
+        debug!("Processing {} release(s)...", self.releases.len());
+        let skip_regex = self.config.git.skip_tags.as_ref();
+        let mut skipped_tags = Vec::new();
+        self.releases = self
+            .releases
+            .clone()
+            .into_iter()
+            .rev()
+            .filter(|release| {
+                if release.commits.is_empty() {
+                    if let Some(version) = release.version.clone() {
+                        trace!("Release doesn't have any commits: {}", version);
+                    }
+                    match &release.previous {
+                        Some(prev_release) if prev_release.commits.is_empty() => {
+                            self.config.changelog.render_always.unwrap_or(false)
+                        }
+                        _ => false,
+                    }
+                } else if let Some(version) = &release.version {
+                    !skip_regex.is_some_and(|r| {
+                        let skip_tag = r.is_match(version);
+                        if skip_tag {
+                            skipped_tags.push(version.clone());
+                            trace!("Skipping release: {}", version);
+                        }
+                        skip_tag
+                    })
+                } else {
+                    true
+                }
+            })
+            .collect();
+        for skipped_tag in &skipped_tags {
+            if let Some(release_index) = self.releases.iter().position(|release| {
+                release
+                    .previous
+                    .as_ref()
+                    .and_then(|release| release.version.as_ref())
+                    == Some(skipped_tag)
+            }) {
+                if let Some(previous_release) = self.releases.get_mut(release_index + 1) {
+                    previous_release.previous = None;
+                    self.releases[release_index].previous =
+                        Some(Box::new(previous_release.clone()));
+                } else if release_index == self.releases.len() - 1 {
+                    self.releases[release_index].previous = None;
+                }
+            }
+        }
+    }
+
+    /// Returns the GitHub metadata needed for the changelog.
+    ///
+    /// This function creates a multithread async runtime for handling the
+    /// requests. The following are fetched from the GitHub REST API:
+    ///
+    /// - Commits
+    /// - Pull requests
+    ///
+    /// Each of these are paginated requests so they are being run in parallel
+    /// for speedup.
+    ///
+    /// If no GitHub related variable is used in the template then this function
+    /// returns empty vectors.
+    #[cfg(feature = "github")]
+    fn get_github_metadata(&self) -> Result<crate::remote::RemoteMetadata> {
+        use crate::remote::github;
+        if self.config.remote.github.is_custom
+            || self
+                .body_template
+                .contains_variable(github::TEMPLATE_VARIABLES)
+            || self
+                .footer_template
+                .as_ref()
+                .map(|v| v.contains_variable(github::TEMPLATE_VARIABLES))
+                .unwrap_or(false)
+        {
+            warn!("You are using an experimental feature! Please report bugs at <https://git-cliff.org/issues>");
+            let github_client = GitHubClient::try_from(self.config.remote.github.clone())?;
+            info!(
+                "{} ({})",
+                github::START_FETCHING_MSG,
+                self.config.remote.github
+            );
+            let data = tokio::runtime::Builder::new_multi_thread()
+                .enable_all()
+                .build()?
+                .block_on(async {
+                    let (commits, pull_requests) = tokio::try_join!(
+                        github_client.get_commits(),
+                        github_client.get_pull_requests(),
+                    )?;
+                    debug!("Number of GitHub commits: {}", commits.len());
+                    debug!("Number of GitHub pull requests: {}", pull_requests.len());
+                    Ok((commits, pull_requests))
+                });
+            info!("{}", github::FINISHED_FETCHING_MSG);
+            data
+        } else {
+            Ok((vec![], vec![]))
+        }
+    }
+
+    /// Returns the GitLab metadata needed for the changelog.
+    ///
+    /// This function creates a multithread async runtime for handling the
+    ///
+    /// requests. The following are fetched from the GitLab REST API:
+    ///
+    /// - Commits
+    /// - Marge requests
+    ///
+    /// Each of these are paginated requests so they are being run in parallel
+    /// for speedup.
+    ///
+    ///
+    /// If no GitLab related variable is used in the template then this function
+    /// returns empty vectors.
+    #[cfg(feature = "gitlab")]
+    fn get_gitlab_metadata(&self) -> Result<crate::remote::RemoteMetadata> {
+        use crate::remote::gitlab;
+        if self.config.remote.gitlab.is_custom
+            || self
+                .body_template
+                .contains_variable(gitlab::TEMPLATE_VARIABLES)
+            || self
+                .footer_template
+                .as_ref()
+                .map(|v| v.contains_variable(gitlab::TEMPLATE_VARIABLES))
+                .unwrap_or(false)
+        {
+            warn!("You are using an experimental feature! Please report bugs at <https://git-cliff.org/issues>");
+            let gitlab_client = GitLabClient::try_from(self.config.remote.gitlab.clone())?;
+            info!(
+                "{} ({})",
+                gitlab::START_FETCHING_MSG,
+                self.config.remote.gitlab
+            );
+            let data = tokio::runtime::Builder::new_multi_thread()
+                .enable_all()
+                .build()?
+                .block_on(async {
+                    // Map repo/owner to gitlab id
+                    let project_id = match tokio::join!(gitlab_client.get_project()) {
+                        (Ok(project),) => project.id,
+                        (Err(err),) => {
+                            error!("Failed to lookup project! {}", err);
+                            return Err(err);
+                        }
+                    };
+                    let (commits, merge_requests) = tokio::try_join!(
+                        // Send id to these functions
+                        gitlab_client.get_commits(project_id),
+                        gitlab_client.get_merge_requests(project_id),
+                    )?;
+                    debug!("Number of GitLab commits: {}", commits.len());
+                    debug!("Number of GitLab merge requests: {}", merge_requests.len());
+                    Ok((commits, merge_requests))
+                });
+            info!("{}", gitlab::FINISHED_FETCHING_MSG);
+            data
+        } else {
+            Ok((vec![], vec![]))
+        }
+    }
+
+    /// Returns the Gitea metadata needed for the changelog.
+    ///
+    /// This function creates a multithread async runtime for handling the
+    /// requests. The following are fetched from the GitHub REST API:
+    ///
+    /// - Commits
+    /// - Pull requests
+    ///
+    /// Each of these are paginated requests so they are being run in parallel
+    /// for speedup.
+    ///
+    /// If no Gitea related variable is used in the template then this function
+    /// returns empty vectors.
+    #[cfg(feature = "gitea")]
+    fn get_gitea_metadata(&self) -> Result<crate::remote::RemoteMetadata> {
+        use crate::remote::gitea;
+        if self.config.remote.gitea.is_custom
+            || self
+                .body_template
+                .contains_variable(gitea::TEMPLATE_VARIABLES)
+            || self
+                .footer_template
+                .as_ref()
+                .map(|v| v.contains_variable(gitea::TEMPLATE_VARIABLES))
+                .unwrap_or(false)
+        {
+            warn!("You are using an experimental feature! Please report bugs at <https://git-cliff.org/issues>");
+            let gitea_client = GiteaClient::try_from(self.config.remote.gitea.clone())?;
+            info!(
+                "{} ({})",
+                gitea::START_FETCHING_MSG,
+                self.config.remote.gitea
+            );
+            let data = tokio::runtime::Builder::new_multi_thread()
+                .enable_all()
+                .build()?
+                .block_on(async {
+                    let (commits, pull_requests) = tokio::try_join!(
+                        gitea_client.get_commits(),
+                        gitea_client.get_pull_requests(),
+                    )?;
+                    debug!("Number of Gitea commits: {}", commits.len());
+                    debug!("Number of Gitea pull requests: {}", pull_requests.len());
+                    Ok((commits, pull_requests))
+                });
+            info!("{}", gitea::FINISHED_FETCHING_MSG);
+            data
+        } else {
+            Ok((vec![], vec![]))
+        }
+    }
+
+    /// Returns the Bitbucket metadata needed for the changelog.
+    ///
+    /// This function creates a multithread async runtime for handling the
+    ///
+    /// requests. The following are fetched from the bitbucket REST API:
+    ///
+    /// - Commits
+    /// - Pull requests
+    ///
+    /// Each of these are paginated requests so they are being run in parallel
+    /// for speedup.
+    ///
+    ///
+    /// If no bitbucket related variable is used in the template then this
+    /// function returns empty vectors.
+    #[cfg(feature = "bitbucket")]
+    fn get_bitbucket_metadata(&self) -> Result<crate::remote::RemoteMetadata> {
+        use crate::remote::bitbucket;
+        if self.config.remote.bitbucket.is_custom
+            || self
+                .body_template
+                .contains_variable(bitbucket::TEMPLATE_VARIABLES)
+            || self
+                .footer_template
+                .as_ref()
+                .map(|v| v.contains_variable(bitbucket::TEMPLATE_VARIABLES))
+                .unwrap_or(false)
+        {
+            warn!("You are using an experimental feature! Please report bugs at <https://git-cliff.org/issues>");
+            let bitbucket_client = BitbucketClient::try_from(self.config.remote.bitbucket.clone())?;
+            info!(
+                "{} ({})",
+                bitbucket::START_FETCHING_MSG,
+                self.config.remote.bitbucket
+            );
+            let data = tokio::runtime::Builder::new_multi_thread()
+                .enable_all()
+                .build()?
+                .block_on(async {
+                    let (commits, pull_requests) = tokio::try_join!(
+                        bitbucket_client.get_commits(),
+                        bitbucket_client.get_pull_requests()
+                    )?;
+                    debug!("Number of Bitbucket commits: {}", commits.len());
+                    debug!("Number of Bitbucket pull requests: {}", pull_requests.len());
+                    Ok((commits, pull_requests))
+                });
+            info!("{}", bitbucket::FINISHED_FETCHING_MSG);
+            data
+        } else {
+            Ok((vec![], vec![]))
+        }
+    }
+
+    /// Adds information about the remote to the template context.
+    pub fn add_remote_context(&mut self) -> Result<()> {
+        self.additional_context.insert(
+            "remote".to_string(),
+            serde_json::to_value(self.config.remote.clone())?,
+        );
+        Ok(())
+    }
+
+    /// Adds remote data (e.g. GitHub commits) to the releases.
+    pub fn add_remote_data(&mut self) -> Result<()> {
+        debug!("Adding remote data...");
+        self.add_remote_context()?;
+
+        #[cfg(feature = "github")]
+        let (github_commits, github_pull_requests) = if self.config.remote.github.is_set() {
+            self.get_github_metadata()
+                .expect("Could not get github metadata")
+        } else {
+            (vec![], vec![])
+        };
+        #[cfg(feature = "gitlab")]
+        let (gitlab_commits, gitlab_merge_request) = if self.config.remote.gitlab.is_set() {
+            self.get_gitlab_metadata()
+                .expect("Could not get gitlab metadata")
+        } else {
+            (vec![], vec![])
+        };
+        #[cfg(feature = "gitea")]
+        let (gitea_commits, gitea_merge_request) = if self.config.remote.gitea.is_set() {
+            self.get_gitea_metadata()
+                .expect("Could not get gitea metadata")
+        } else {
+            (vec![], vec![])
+        };
+        #[cfg(feature = "bitbucket")]
+        let (bitbucket_commits, bitbucket_pull_request) = if self.config.remote.bitbucket.is_set() {
+            self.get_bitbucket_metadata()
+                .expect("Could not get bitbucket metadata")
+        } else {
+            (vec![], vec![])
+        };
+        #[cfg(feature = "remote")]
+        for release in &mut self.releases {
+            #[cfg(feature = "github")]
+            release.update_github_metadata(github_commits.clone(), github_pull_requests.clone())?;
+            #[cfg(feature = "gitlab")]
+            release.update_gitlab_metadata(gitlab_commits.clone(), gitlab_merge_request.clone())?;
+            #[cfg(feature = "gitea")]
+            release.update_gitea_metadata(gitea_commits.clone(), gitea_merge_request.clone())?;
+            #[cfg(feature = "bitbucket")]
+            release.update_bitbucket_metadata(
+                bitbucket_commits.clone(),
+                bitbucket_pull_request.clone(),
+            )?;
+        }
+        Ok(())
+    }
+
+    /// Increments the version for the unreleased changes based on semver.
+    pub fn bump_version(&mut self) -> Result<Option<String>> {
+        if let Some(ref mut last_release) = self.releases.iter_mut().next() {
+            if last_release.version.is_none() {
+                let next_version =
+                    last_release.calculate_next_version_with_config(&self.config.bump)?;
+                debug!("Bumping the version to {next_version}");
+                last_release.version = Some(next_version.to_string());
+                last_release.timestamp = SystemTime::now()
+                    .duration_since(UNIX_EPOCH)?
+                    .as_secs()
+                    .try_into()?;
+                return Ok(Some(next_version));
+            }
+        }
+        Ok(None)
+    }
+
+    /// Generates the changelog and writes it to the given output.
+    pub fn generate<W: Write + ?Sized>(&self, out: &mut W) -> Result<()> {
+        debug!("Generating changelog...");
+        let postprocessors = self
+            .config
+            .changelog
+            .postprocessors
+            .clone()
+            .unwrap_or_default();
+
+        if let Some(header_template) = &self.header_template {
+            let write_result = writeln!(
+                out,
+                "{}",
+                header_template.render(
+                    &Releases {
+                        releases: &self.releases,
+                    },
+                    Some(&self.additional_context),
+                    &postprocessors,
+                )?
+            );
+            if let Err(e) = write_result {
+                if e.kind() != std::io::ErrorKind::BrokenPipe {
+                    return Err(e.into());
+                }
+            }
+        }
+
+        for release in &self.releases {
+            let write_result = write!(
+                out,
+                "{}",
+                self.body_template.render(
+                    &release,
+                    Some(&self.additional_context),
+                    &postprocessors
+                )?
+            );
+            if let Err(e) = write_result {
+                if e.kind() != std::io::ErrorKind::BrokenPipe {
+                    return Err(e.into());
+                }
+            }
+        }
+
+        if let Some(footer_template) = &self.footer_template {
+            let write_result = writeln!(
+                out,
+                "{}",
+                footer_template.render(
+                    &Releases {
+                        releases: &self.releases,
+                    },
+                    Some(&self.additional_context),
+                    &postprocessors,
+                )?
+            );
+            if let Err(e) = write_result {
+                if e.kind() != std::io::ErrorKind::BrokenPipe {
+                    return Err(e.into());
+                }
+            }
+        }
+
+        Ok(())
+    }
+
+    /// Generates a changelog and prepends it to the given changelog.
+    pub fn prepend<W: Write + ?Sized>(&self, mut changelog: String, out: &mut W) -> Result<()> {
+        debug!("Generating changelog and prepending...");
+        if let Some(header) = &self.config.changelog.header {
+            changelog = changelog.replacen(header, "", 1);
+        }
+        self.generate(out)?;
+        write!(out, "{changelog}")?;
+        Ok(())
+    }
+
+    /// Prints the changelog context to the given output.
+    pub fn write_context<W: Write + ?Sized>(&self, out: &mut W) -> Result<()> {
+        let output = Releases {
+            releases: &self.releases,
+        }
+        .as_json()?;
+        writeln!(out, "{output}")?;
+        Ok(())
+    }
 }
 
 fn get_body_template(config: &Config, trim: bool) -> Result<Template> {
-	let template_str = config
-		.changelog
-		.body
-		.as_deref()
-		.unwrap_or_default()
-		.to_string();
-	let template = Template::new("body", template_str, trim)?;
-	let deprecated_vars = [
-		"commit.github",
-		"commit.gitea",
-		"commit.gitlab",
-		"commit.bitbucket",
-	];
-	if template.contains_variable(&deprecated_vars) {
-		warn!(
-			"Variables {deprecated_vars:?} are deprecated and will be removed in \
+    let template_str = config
+        .changelog
+        .body
+        .as_deref()
+        .unwrap_or_default()
+        .to_string();
+    let template = Template::new("body", template_str, trim)?;
+    let deprecated_vars = [
+        "commit.github",
+        "commit.gitea",
+        "commit.gitlab",
+        "commit.bitbucket",
+    ];
+    if template.contains_variable(&deprecated_vars) {
+        warn!(
+            "Variables {deprecated_vars:?} are deprecated and will be removed in \
 			 the future. Use `commit.remote` instead."
-		);
-	}
-	Ok(template)
+        );
+    }
+    Ok(template)
 }
 
 #[cfg(test)]
 mod test {
-	use super::*;
-	use crate::config::{
-		Bump,
-		ChangelogConfig,
-		CommitParser,
-		Remote,
-		RemoteConfig,
-		TextProcessor,
-	};
-	use pretty_assertions::assert_eq;
-	use regex::Regex;
-	use std::str;
-
-	fn get_test_data() -> (Config, Vec<Release<'static>>) {
-		let config = Config {
-			changelog: ChangelogConfig {
-				header:         Some(String::from("# Changelog")),
-				body:           Some(String::from(
-					r#"{% if version %}
+    use super::*;
+    use crate::config::{Bump, ChangelogConfig, CommitParser, Remote, RemoteConfig, TextProcessor};
+    use pretty_assertions::assert_eq;
+    use regex::Regex;
+    use std::str;
+
+    fn get_test_data() -> (Config, Vec<Release<'static>>) {
+        let config = Config {
+            changelog: ChangelogConfig {
+                header: Some(String::from("# Changelog")),
+                body: Some(String::from(
+                    r#"{% if version %}
 				## Release [{{ version }}] - {{ timestamp | date(format="%Y-%m-%d") }} - ({{ repository }})
 				{% if commit_id %}({{ commit_id }}){% endif %}{% else %}
 				## Unreleased{% endif %}
@@ -664,370 +614,348 @@ mod test {
 				#### {{ group }}{% for commit in commits %}
 				- {{ commit.message }}{% endfor %}
 				{% endfor %}{% endfor %}"#,
-				)),
-				footer:         Some(String::from(
-					r#"-- total releases: {{ releases | length }} --"#,
-				)),
-				trim:           Some(true),
-				postprocessors: Some(vec![TextProcessor {
-					pattern:         Regex::new("boring")
-						.expect("failed to compile regex"),
-					replace:         Some(String::from("exciting")),
-					replace_command: None,
-				}]),
-				render_always:  None,
-				output:         None,
-			},
-			git:       GitConfig {
-				conventional_commits:     Some(true),
-				filter_unconventional:    Some(false),
-				split_commits:            Some(false),
-				commit_preprocessors:     Some(vec![TextProcessor {
-					pattern:         Regex::new("<preprocess>")
-						.expect("failed to compile regex"),
-					replace:         Some(String::from(
-						"this commit is preprocessed",
-					)),
-					replace_command: None,
-				}]),
-				commit_parsers:           Some(vec![
-					CommitParser {
-						sha:           Some(String::from("tea")),
-						message:       None,
-						body:          None,
-						footer:        None,
-						group:         Some(String::from("I love tea")),
-						default_scope: None,
-						scope:         None,
-						skip:          None,
-						field:         None,
-						pattern:       None,
-					},
-					CommitParser {
-						sha:           Some(String::from("coffee")),
-						message:       None,
-						body:          None,
-						footer:        None,
-						group:         None,
-						default_scope: None,
-						scope:         None,
-						skip:          Some(true),
-						field:         None,
-						pattern:       None,
-					},
-					CommitParser {
-						sha:           Some(String::from("coffee2")),
-						message:       None,
-						body:          None,
-						footer:        None,
-						group:         None,
-						default_scope: None,
-						scope:         None,
-						skip:          Some(true),
-						field:         None,
-						pattern:       None,
-					},
-					CommitParser {
-						sha:           None,
-						message:       Regex::new(r".*merge.*").ok(),
-						body:          None,
-						footer:        None,
-						group:         None,
-						default_scope: None,
-						scope:         None,
-						skip:          Some(true),
-						field:         None,
-						pattern:       None,
-					},
-					CommitParser {
-						sha:           None,
-						message:       Regex::new("feat*").ok(),
-						body:          None,
-						footer:        None,
-						group:         Some(String::from("New features")),
-						default_scope: Some(String::from("other")),
-						scope:         None,
-						skip:          None,
-						field:         None,
-						pattern:       None,
-					},
-					CommitParser {
-						sha:           None,
-						message:       Regex::new("^fix*").ok(),
-						body:          None,
-						footer:        None,
-						group:         Some(String::from("Bug Fixes")),
-						default_scope: None,
-						scope:         None,
-						skip:          None,
-						field:         None,
-						pattern:       None,
-					},
-					CommitParser {
-						sha:           None,
-						message:       Regex::new("doc:").ok(),
-						body:          None,
-						footer:        None,
-						group:         Some(String::from("Documentation")),
-						default_scope: None,
-						scope:         Some(String::from("documentation")),
-						skip:          None,
-						field:         None,
-						pattern:       None,
-					},
-					CommitParser {
-						sha:           None,
-						message:       Regex::new("docs:").ok(),
-						body:          None,
-						footer:        None,
-						group:         Some(String::from("Documentation")),
-						default_scope: None,
-						scope:         Some(String::from("documentation")),
-						skip:          None,
-						field:         None,
-						pattern:       None,
-					},
-					CommitParser {
-						sha:           None,
-						message:       Regex::new(r"match\((.*)\):.*").ok(),
-						body:          None,
-						footer:        None,
-						group:         Some(String::from("Matched ($1)")),
-						default_scope: None,
-						scope:         None,
-						skip:          None,
-						field:         None,
-						pattern:       None,
-					},
-					CommitParser {
-						sha:           None,
-						message:       None,
-						body:          None,
-						footer:        Regex::new("Footer:.*").ok(),
-						group:         Some(String::from("Footer")),
-						default_scope: None,
-						scope:         Some(String::from("footer")),
-						skip:          None,
-						field:         None,
-						pattern:       None,
-					},
-					CommitParser {
-						sha:           None,
-						message:       Regex::new(".*").ok(),
-						body:          None,
-						footer:        None,
-						group:         Some(String::from("Other")),
-						default_scope: Some(String::from("other")),
-						scope:         None,
-						skip:          None,
-						field:         None,
-						pattern:       None,
-					},
-				]),
-				protect_breaking_commits: None,
-				filter_commits:           Some(false),
-				tag_pattern:              None,
-				skip_tags:                Regex::new("v3.*").ok(),
-				ignore_tags:              None,
-				count_tags:               None,
-				use_branch_tags:          Some(false),
-				topo_order:               Some(false),
-				sort_commits:             Some(String::from("oldest")),
-				link_parsers:             None,
-				limit_commits:            None,
-			},
-			remote:    RemoteConfig {
-				github:    Remote {
-					owner:     String::from("coolguy"),
-					repo:      String::from("awesome"),
-					token:     None,
-					is_custom: false,
-				},
-				gitlab:    Remote {
-					owner:     String::from("coolguy"),
-					repo:      String::from("awesome"),
-					token:     None,
-					is_custom: false,
-				},
-				gitea:     Remote {
-					owner:     String::from("coolguy"),
-					repo:      String::from("awesome"),
-					token:     None,
-					is_custom: false,
-				},
-				bitbucket: Remote {
-					owner:     String::from("coolguy"),
-					repo:      String::from("awesome"),
-					token:     None,
-					is_custom: false,
-				},
-			},
-			bump:      Bump::default(),
-		};
-		let test_release = Release {
-			version: Some(String::from("v1.0.0")),
-			message: None,
-			extra: None,
-			commits: vec![
-				Commit::new(
-					String::from("coffee"),
-					String::from("revert(app): skip this commit"),
-				),
-				Commit::new(
-					String::from("tea"),
-					String::from("feat(app): damn right"),
-				),
-				Commit::new(
-					String::from("0bc123"),
-					String::from("feat(app): add cool features"),
-				),
-				Commit::new(
-					String::from("000000"),
-					String::from("support unconventional commits"),
-				),
-				Commit::new(
-					String::from("0bc123"),
-					String::from("feat: support unscoped commits"),
-				),
-				Commit::new(
-					String::from("0werty"),
-					String::from("style(ui): make good stuff"),
-				),
-				Commit::new(
-					String::from("0w3rty"),
-					String::from("fix(ui): fix more stuff"),
-				),
-				Commit::new(
-					String::from("qw3rty"),
-					String::from("doc: update docs"),
-				),
-				Commit::new(
-					String::from("0bc123"),
-					String::from("docs: add some documentation"),
-				),
-				Commit::new(
-					String::from("0jkl12"),
-					String::from("chore(app): do nothing"),
-				),
-				Commit::new(
-					String::from("qwerty"),
-					String::from("chore: <preprocess>"),
-				),
-				Commit::new(
-					String::from("qwertz"),
-					String::from("feat!: support breaking commits"),
-				),
-				Commit::new(
-					String::from("qwert0"),
-					String::from("match(group): support regex-replace for groups"),
-				),
-				Commit::new(
-					String::from("coffee"),
-					String::from("revert(app): skip this commit"),
-				),
-				Commit::new(
-					String::from("footer"),
-					String::from("misc: use footer\n\nFooter: footer text"),
-				),
-			],
-			commit_id: Some(String::from("0bc123")),
-			timestamp: 50000000,
-			previous: None,
-			repository: Some(String::from("/root/repo")),
-			#[cfg(feature = "github")]
-			github: crate::remote::RemoteReleaseMetadata {
-				contributors: vec![],
-			},
-			#[cfg(feature = "gitlab")]
-			gitlab: crate::remote::RemoteReleaseMetadata {
-				contributors: vec![],
-			},
-			#[cfg(feature = "gitea")]
-			gitea: crate::remote::RemoteReleaseMetadata {
-				contributors: vec![],
-			},
-			#[cfg(feature = "bitbucket")]
-			bitbucket: crate::remote::RemoteReleaseMetadata {
-				contributors: vec![],
-			},
-		};
-		let releases = vec![
-			test_release.clone(),
-			Release {
-				version: Some(String::from("v3.0.0")),
-				commits: vec![Commit::new(
-					String::from("n0thin"),
-					String::from("feat(xyz): skip commit"),
-				)],
-				..Release::default()
-			},
-			Release {
-				version: None,
-				message: None,
-				extra: None,
-				commits: vec![
-					Commit::new(
-						String::from("abc123"),
-						String::from("feat(app): add xyz"),
-					),
-					Commit::new(
-						String::from("abc124"),
-						String::from("docs(app): document zyx"),
-					),
-					Commit::new(String::from("def789"), String::from("merge #4")),
-					Commit::new(
-						String::from("dev063"),
-						String::from("feat(app)!: merge #5"),
-					),
-					Commit::new(
-						String::from("qwerty"),
-						String::from("fix(app): fix abc"),
-					),
-					Commit::new(
-						String::from("hjkl12"),
-						String::from("chore(ui): do boring stuff"),
-					),
-					Commit::new(
-						String::from("coffee2"),
-						String::from("revert(app): skip this commit"),
-					),
-				],
-				commit_id: None,
-				timestamp: 1000,
-				previous: Some(Box::new(test_release)),
-				repository: Some(String::from("/root/repo")),
-				#[cfg(feature = "github")]
-				github: crate::remote::RemoteReleaseMetadata {
-					contributors: vec![],
-				},
-				#[cfg(feature = "gitlab")]
-				gitlab: crate::remote::RemoteReleaseMetadata {
-					contributors: vec![],
-				},
-				#[cfg(feature = "gitea")]
-				gitea: crate::remote::RemoteReleaseMetadata {
-					contributors: vec![],
-				},
-				#[cfg(feature = "bitbucket")]
-				bitbucket: crate::remote::RemoteReleaseMetadata {
-					contributors: vec![],
-				},
-			},
-		];
-		(config, releases)
-	}
-
-	#[test]
-	fn changelog_generator() -> Result<()> {
-		let (config, releases) = get_test_data();
-		let mut changelog = Changelog::new(releases, &config)?;
-		changelog.bump_version()?;
-		changelog.releases[0].timestamp = 0;
-		let mut out = Vec::new();
-		changelog.generate(&mut out)?;
-		assert_eq!(
-			String::from(
-				r#"# Changelog
+                )),
+                footer: Some(String::from(
+                    r#"-- total releases: {{ releases | length }} --"#,
+                )),
+                trim: Some(true),
+                postprocessors: Some(vec![TextProcessor {
+                    pattern: Regex::new("boring").expect("failed to compile regex"),
+                    replace: Some(String::from("exciting")),
+                    replace_command: None,
+                }]),
+                render_always: None,
+                output: None,
+            },
+            git: GitConfig {
+                conventional_commits: Some(true),
+                filter_unconventional: Some(false),
+                split_commits: Some(false),
+                commit_preprocessors: Some(vec![TextProcessor {
+                    pattern: Regex::new("<preprocess>").expect("failed to compile regex"),
+                    replace: Some(String::from("this commit is preprocessed")),
+                    replace_command: None,
+                }]),
+                commit_parsers: Some(vec![
+                    CommitParser {
+                        sha: Some(String::from("tea")),
+                        message: None,
+                        body: None,
+                        footer: None,
+                        group: Some(String::from("I love tea")),
+                        default_scope: None,
+                        scope: None,
+                        skip: None,
+                        field: None,
+                        pattern: None,
+                    },
+                    CommitParser {
+                        sha: Some(String::from("coffee")),
+                        message: None,
+                        body: None,
+                        footer: None,
+                        group: None,
+                        default_scope: None,
+                        scope: None,
+                        skip: Some(true),
+                        field: None,
+                        pattern: None,
+                    },
+                    CommitParser {
+                        sha: Some(String::from("coffee2")),
+                        message: None,
+                        body: None,
+                        footer: None,
+                        group: None,
+                        default_scope: None,
+                        scope: None,
+                        skip: Some(true),
+                        field: None,
+                        pattern: None,
+                    },
+                    CommitParser {
+                        sha: None,
+                        message: Regex::new(r".*merge.*").ok(),
+                        body: None,
+                        footer: None,
+                        group: None,
+                        default_scope: None,
+                        scope: None,
+                        skip: Some(true),
+                        field: None,
+                        pattern: None,
+                    },
+                    CommitParser {
+                        sha: None,
+                        message: Regex::new("feat*").ok(),
+                        body: None,
+                        footer: None,
+                        group: Some(String::from("New features")),
+                        default_scope: Some(String::from("other")),
+                        scope: None,
+                        skip: None,
+                        field: None,
+                        pattern: None,
+                    },
+                    CommitParser {
+                        sha: None,
+                        message: Regex::new("^fix*").ok(),
+                        body: None,
+                        footer: None,
+                        group: Some(String::from("Bug Fixes")),
+                        default_scope: None,
+                        scope: None,
+                        skip: None,
+                        field: None,
+                        pattern: None,
+                    },
+                    CommitParser {
+                        sha: None,
+                        message: Regex::new("doc:").ok(),
+                        body: None,
+                        footer: None,
+                        group: Some(String::from("Documentation")),
+                        default_scope: None,
+                        scope: Some(String::from("documentation")),
+                        skip: None,
+                        field: None,
+                        pattern: None,
+                    },
+                    CommitParser {
+                        sha: None,
+                        message: Regex::new("docs:").ok(),
+                        body: None,
+                        footer: None,
+                        group: Some(String::from("Documentation")),
+                        default_scope: None,
+                        scope: Some(String::from("documentation")),
+                        skip: None,
+                        field: None,
+                        pattern: None,
+                    },
+                    CommitParser {
+                        sha: None,
+                        message: Regex::new(r"match\((.*)\):.*").ok(),
+                        body: None,
+                        footer: None,
+                        group: Some(String::from("Matched ($1)")),
+                        default_scope: None,
+                        scope: None,
+                        skip: None,
+                        field: None,
+                        pattern: None,
+                    },
+                    CommitParser {
+                        sha: None,
+                        message: None,
+                        body: None,
+                        footer: Regex::new("Footer:.*").ok(),
+                        group: Some(String::from("Footer")),
+                        default_scope: None,
+                        scope: Some(String::from("footer")),
+                        skip: None,
+                        field: None,
+                        pattern: None,
+                    },
+                    CommitParser {
+                        sha: None,
+                        message: Regex::new(".*").ok(),
+                        body: None,
+                        footer: None,
+                        group: Some(String::from("Other")),
+                        default_scope: Some(String::from("other")),
+                        scope: None,
+                        skip: None,
+                        field: None,
+                        pattern: None,
+                    },
+                ]),
+                protect_breaking_commits: None,
+                filter_commits: Some(false),
+                tag_pattern: None,
+                skip_tags: Regex::new("v3.*").ok(),
+                ignore_tags: None,
+                count_tags: None,
+                use_branch_tags: Some(false),
+                topo_order: Some(false),
+                sort_commits: Some(String::from("oldest")),
+                link_parsers: None,
+                limit_commits: None,
+            },
+            remote: RemoteConfig {
+                github: Remote {
+                    owner: String::from("coolguy"),
+                    repo: String::from("awesome"),
+                    token: None,
+                    is_custom: false,
+                },
+                gitlab: Remote {
+                    owner: String::from("coolguy"),
+                    repo: String::from("awesome"),
+                    token: None,
+                    is_custom: false,
+                },
+                gitea: Remote {
+                    owner: String::from("coolguy"),
+                    repo: String::from("awesome"),
+                    token: None,
+                    is_custom: false,
+                },
+                bitbucket: Remote {
+                    owner: String::from("coolguy"),
+                    repo: String::from("awesome"),
+                    token: None,
+                    is_custom: false,
+                },
+            },
+            bump: Bump::default(),
+        };
+        let test_release = Release {
+            version: Some(String::from("v1.0.0")),
+            message: None,
+            extra: None,
+            commits: vec![
+                Commit::new(
+                    String::from("coffee"),
+                    String::from("revert(app): skip this commit"),
+                ),
+                Commit::new(String::from("tea"), String::from("feat(app): damn right")),
+                Commit::new(
+                    String::from("0bc123"),
+                    String::from("feat(app): add cool features"),
+                ),
+                Commit::new(
+                    String::from("000000"),
+                    String::from("support unconventional commits"),
+                ),
+                Commit::new(
+                    String::from("0bc123"),
+                    String::from("feat: support unscoped commits"),
+                ),
+                Commit::new(
+                    String::from("0werty"),
+                    String::from("style(ui): make good stuff"),
+                ),
+                Commit::new(
+                    String::from("0w3rty"),
+                    String::from("fix(ui): fix more stuff"),
+                ),
+                Commit::new(String::from("qw3rty"), String::from("doc: update docs")),
+                Commit::new(
+                    String::from("0bc123"),
+                    String::from("docs: add some documentation"),
+                ),
+                Commit::new(
+                    String::from("0jkl12"),
+                    String::from("chore(app): do nothing"),
+                ),
+                Commit::new(String::from("qwerty"), String::from("chore: <preprocess>")),
+                Commit::new(
+                    String::from("qwertz"),
+                    String::from("feat!: support breaking commits"),
+                ),
+                Commit::new(
+                    String::from("qwert0"),
+                    String::from("match(group): support regex-replace for groups"),
+                ),
+                Commit::new(
+                    String::from("coffee"),
+                    String::from("revert(app): skip this commit"),
+                ),
+                Commit::new(
+                    String::from("footer"),
+                    String::from("misc: use footer\n\nFooter: footer text"),
+                ),
+            ],
+            commit_id: Some(String::from("0bc123")),
+            timestamp: 50000000,
+            previous: None,
+            repository: Some(String::from("/root/repo")),
+            #[cfg(feature = "github")]
+            github: crate::remote::RemoteReleaseMetadata {
+                contributors: vec![],
+            },
+            #[cfg(feature = "gitlab")]
+            gitlab: crate::remote::RemoteReleaseMetadata {
+                contributors: vec![],
+            },
+            #[cfg(feature = "gitea")]
+            gitea: crate::remote::RemoteReleaseMetadata {
+                contributors: vec![],
+            },
+            #[cfg(feature = "bitbucket")]
+            bitbucket: crate::remote::RemoteReleaseMetadata {
+                contributors: vec![],
+            },
+        };
+        let releases = vec![
+            test_release.clone(),
+            Release {
+                version: Some(String::from("v3.0.0")),
+                commits: vec![Commit::new(
+                    String::from("n0thin"),
+                    String::from("feat(xyz): skip commit"),
+                )],
+                ..Release::default()
+            },
+            Release {
+                version: None,
+                message: None,
+                extra: None,
+                commits: vec![
+                    Commit::new(String::from("abc123"), String::from("feat(app): add xyz")),
+                    Commit::new(
+                        String::from("abc124"),
+                        String::from("docs(app): document zyx"),
+                    ),
+                    Commit::new(String::from("def789"), String::from("merge #4")),
+                    Commit::new(String::from("dev063"), String::from("feat(app)!: merge #5")),
+                    Commit::new(String::from("qwerty"), String::from("fix(app): fix abc")),
+                    Commit::new(
+                        String::from("hjkl12"),
+                        String::from("chore(ui): do boring stuff"),
+                    ),
+                    Commit::new(
+                        String::from("coffee2"),
+                        String::from("revert(app): skip this commit"),
+                    ),
+                ],
+                commit_id: None,
+                timestamp: 1000,
+                previous: Some(Box::new(test_release)),
+                repository: Some(String::from("/root/repo")),
+                #[cfg(feature = "github")]
+                github: crate::remote::RemoteReleaseMetadata {
+                    contributors: vec![],
+                },
+                #[cfg(feature = "gitlab")]
+                gitlab: crate::remote::RemoteReleaseMetadata {
+                    contributors: vec![],
+                },
+                #[cfg(feature = "gitea")]
+                gitea: crate::remote::RemoteReleaseMetadata {
+                    contributors: vec![],
+                },
+                #[cfg(feature = "bitbucket")]
+                bitbucket: crate::remote::RemoteReleaseMetadata {
+                    contributors: vec![],
+                },
+            },
+        ];
+        (config, releases)
+    }
+
+    #[test]
+    fn changelog_generator() -> Result<()> {
+        let (config, releases) = get_test_data();
+        let mut changelog = Changelog::new(releases, &config)?;
+        changelog.bump_version()?;
+        changelog.releases[0].timestamp = 0;
+        let mut out = Vec::new();
+        changelog.generate(&mut out)?;
+        assert_eq!(
+            String::from(
+                r#"# Changelog
 
 			## Release [v1.1.0] - 1970-01-01 - (/root/repo)
 
@@ -1091,60 +1019,60 @@ mod test {
 			- make good stuff
 			-- total releases: 2 --
 			"#
-			)
-			.replace("			", ""),
-			str::from_utf8(&out).unwrap_or_default()
-		);
-		Ok(())
-	}
-
-	#[test]
-	fn changelog_generator_split_commits() -> Result<()> {
-		let (mut config, mut releases) = get_test_data();
-		config.git.split_commits = Some(true);
-		config.git.filter_unconventional = Some(false);
-		config.git.protect_breaking_commits = Some(true);
-
-		if let Some(parsers) = config.git.commit_parsers.as_mut() {
-			for parser in parsers.iter_mut().filter(|p| p.footer.is_some()) {
-				parser.skip = Some(true);
-			}
-		}
-
-		releases[0].commits.push(Commit::new(
-			String::from("0bc123"),
-			String::from(
-				"feat(app): add some more cool features
+            )
+            .replace("			", ""),
+            str::from_utf8(&out).unwrap_or_default()
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn changelog_generator_split_commits() -> Result<()> {
+        let (mut config, mut releases) = get_test_data();
+        config.git.split_commits = Some(true);
+        config.git.filter_unconventional = Some(false);
+        config.git.protect_breaking_commits = Some(true);
+
+        if let Some(parsers) = config.git.commit_parsers.as_mut() {
+            for parser in parsers.iter_mut().filter(|p| p.footer.is_some()) {
+                parser.skip = Some(true);
+            }
+        }
+
+        releases[0].commits.push(Commit::new(
+            String::from("0bc123"),
+            String::from(
+                "feat(app): add some more cool features
 feat(app): even more features
 feat(app): feature #3
 ",
-			),
-		));
-		releases[0].commits.push(Commit::new(
-			String::from("003934"),
-			String::from(
-				"feat: add awesome stuff
+            ),
+        ));
+        releases[0].commits.push(Commit::new(
+            String::from("003934"),
+            String::from(
+                "feat: add awesome stuff
 fix(backend): fix awesome stuff
 style: make awesome stuff look better
 ",
-			),
-		));
-		releases[2].commits.push(Commit::new(
-			String::from("123abc"),
-			String::from(
-				"chore(deps): bump some deps
+            ),
+        ));
+        releases[2].commits.push(Commit::new(
+            String::from("123abc"),
+            String::from(
+                "chore(deps): bump some deps
 
 chore(deps): bump some more deps
 chore(deps): fix broken deps
 ",
-			),
-		));
-		let changelog = Changelog::new(releases, &config)?;
-		let mut out = Vec::new();
-		changelog.generate(&mut out)?;
-		assert_eq!(
-			String::from(
-				r#"# Changelog
+            ),
+        ));
+        let changelog = Changelog::new(releases, &config)?;
+        let mut out = Vec::new();
+        changelog.generate(&mut out)?;
+        assert_eq!(
+            String::from(
+                r#"# Changelog
 
 			## Unreleased
 
@@ -1220,19 +1148,19 @@ chore(deps): fix broken deps
 			- make good stuff
 			-- total releases: 2 --
 			"#
-			)
-			.replace("			", ""),
-			str::from_utf8(&out).unwrap_or_default()
-		);
-		Ok(())
-	}
-
-	#[test]
-	fn changelog_adds_additional_context() -> Result<()> {
-		let (mut config, releases) = get_test_data();
-		// add `{{ custom_field }}` to the template
-		config.changelog.body = Some(
-			r#"{% if version %}
+            )
+            .replace("			", ""),
+            str::from_utf8(&out).unwrap_or_default()
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn changelog_adds_additional_context() -> Result<()> {
+        let (mut config, releases) = get_test_data();
+        // add `{{ custom_field }}` to the template
+        config.changelog.body = Some(
+            r#"{% if version %}
 				## {{ custom_field }} [{{ version }}] - {{ timestamp | date(format="%Y-%m-%d") }}
 				{% if commit_id %}({{ commit_id }}){% endif %}{% else %}
 				## Unreleased{% endif %}
@@ -1241,13 +1169,13 @@ chore(deps): fix broken deps
 				#### {{ group }}{% for commit in commits %}
 				- {{ commit.message }}{% endfor %}
 				{% endfor %}{% endfor %}"#
-				.to_string(),
-		);
-		let mut changelog = Changelog::new(releases, &config)?;
-		changelog.add_context("custom_field", "Hello")?;
-		let mut out = Vec::new();
-		changelog.generate(&mut out)?;
-		expect_test::expect![[r#"
+                .to_string(),
+        );
+        let mut changelog = Changelog::new(releases, &config)?;
+        changelog.add_context("custom_field", "Hello")?;
+        let mut out = Vec::new();
+        changelog.generate(&mut out)?;
+        expect_test::expect![[r#"
     # Changelog
 
     ## Unreleased
@@ -1311,7 +1239,7 @@ chore(deps): fix broken deps
     - make good stuff
     -- total releases: 2 --
 "#]]
-		.assert_eq(str::from_utf8(&out).unwrap_or_default());
-		Ok(())
-	}
+        .assert_eq(str::from_utf8(&out).unwrap_or_default());
+        Ok(())
+    }
 }
diff --git a/git-cliff-core/src/command.rs b/git-cliff-core/src/command.rs
index c04a48db0d..8dd8f8117c 100644
--- a/git-cliff-core/src/command.rs
+++ b/git-cliff-core/src/command.rs
@@ -1,93 +1,81 @@
 use crate::error::Result;
-use std::io::{
-	Error as IoError,
-	ErrorKind as IoErrorKind,
-	Write,
-};
-use std::process::{
-	Command,
-	Stdio,
-};
+use std::io::{Error as IoError, ErrorKind as IoErrorKind, Write};
+use std::process::{Command, Stdio};
 use std::thread;
-use std::{
-	env,
-	str,
-};
+use std::{env, str};
 
 /// Runs the given OS command and returns the output as string.
 ///
 /// Use `input` parameter to specify a text to write to stdin.
 /// Environment variables are set accordingly to `envs`.
-pub fn run(
-	command: &str,
-	input: Option<String>,
-	envs: Vec<(&str, &str)>,
-) -> Result<String> {
-	let mut child = if cfg!(target_os = "windows") {
-		Command::new("cmd")
-			.envs(envs)
-			.args(["/C", command])
-			.stdin(Stdio::piped())
-			.stdout(Stdio::piped())
-			.current_dir(env::current_dir()?)
-			.spawn()
-	} else {
-		Command::new("sh")
-			.envs(envs)
-			.args(["-c", command])
-			.stdin(Stdio::piped())
-			.stdout(Stdio::piped())
-			.current_dir(env::current_dir()?)
-			.spawn()
-	}?;
-	if let Some(input) = input {
-		let mut stdin = child.stdin.take().ok_or_else(|| {
-			IoError::new(IoErrorKind::Other, "stdin is not captured")
-		})?;
-		thread::spawn(move || {
-			stdin
-				.write_all(input.as_bytes())
-				.expect("Failed to write to stdin");
-		});
-	}
-	let output = child.wait_with_output()?;
-	if output.status.success() {
-		Ok(str::from_utf8(&output.stdout)?.to_string())
-	} else {
-		for output in [output.stdout, output.stderr] {
-			let output = str::from_utf8(&output)?.to_string();
-			if !output.is_empty() {
-				log::error!("{}", output);
-			}
-		}
-		Err(IoError::new(
-			IoErrorKind::Other,
-			format!("command exited with {:?}", output.status),
-		)
-		.into())
-	}
+pub fn run(command: &str, input: Option<String>, envs: Vec<(&str, &str)>) -> Result<String> {
+    let mut child = if cfg!(target_os = "windows") {
+        Command::new("cmd")
+            .envs(envs)
+            .args(["/C", command])
+            .stdin(Stdio::piped())
+            .stdout(Stdio::piped())
+            .current_dir(env::current_dir()?)
+            .spawn()
+    } else {
+        Command::new("sh")
+            .envs(envs)
+            .args(["-c", command])
+            .stdin(Stdio::piped())
+            .stdout(Stdio::piped())
+            .current_dir(env::current_dir()?)
+            .spawn()
+    }?;
+    if let Some(input) = input {
+        let mut stdin = child
+            .stdin
+            .take()
+            .ok_or_else(|| IoError::new(IoErrorKind::Other, "stdin is not captured"))?;
+        thread::spawn(move || {
+            stdin
+                .write_all(input.as_bytes())
+                .expect("Failed to write to stdin");
+        });
+    }
+    let output = child.wait_with_output()?;
+    if output.status.success() {
+        Ok(str::from_utf8(&output.stdout)?.to_string())
+    } else {
+        for output in [output.stdout, output.stderr] {
+            let output = str::from_utf8(&output)?.to_string();
+            if !output.is_empty() {
+                log::error!("{}", output);
+            }
+        }
+        Err(IoError::new(
+            IoErrorKind::Other,
+            format!("command exited with {:?}", output.status),
+        )
+        .into())
+    }
 }
 
 #[cfg(test)]
 mod test {
-	use super::*;
-	#[test]
-	#[cfg(target_family = "unix")]
-	fn run_os_command() -> Result<()> {
-		assert_eq!(
-			"eroc-ffilc-tig",
-			run("echo $APP_NAME | rev", None, vec![(
-				"APP_NAME",
-				env!("CARGO_PKG_NAME")
-			)])?
-			.trim()
-		);
-		assert_eq!(
-			"eroc-ffilc-tig",
-			run("rev", Some(env!("CARGO_PKG_NAME").to_string()), vec![])?.trim()
-		);
-		assert_eq!("testing", run("echo 'testing'", None, vec![])?.trim());
-		assert!(run("some_command", None, vec![]).is_err());
-		Ok(())
-	}
+    use super::*;
+    #[test]
+    #[cfg(target_family = "unix")]
+    fn run_os_command() -> Result<()> {
+        assert_eq!(
+            "eroc-ffilc-tig",
+            run(
+                "echo $APP_NAME | rev",
+                None,
+                vec![("APP_NAME", env!("CARGO_PKG_NAME"))]
+            )?
+            .trim()
+        );
+        assert_eq!(
+            "eroc-ffilc-tig",
+            run("rev", Some(env!("CARGO_PKG_NAME").to_string()), vec![])?.trim()
+        );
+        assert_eq!("testing", run("echo 'testing'", None, vec![])?.trim());
+        assert!(run("some_command", None, vec![]).is_err());
+        Ok(())
+    }
 }
diff --git a/git-cliff-core/src/commit.rs b/git-cliff-core/src/commit.rs
index 0f349efa36..3622d44f2e 100644
--- a/git-cliff-core/src/commit.rs
+++ b/git-cliff-core/src/commit.rs
@@ -1,35 +1,11 @@
-use crate::config::{
-	CommitParser,
-	GitConfig,
-	LinkParser,
-	TextProcessor,
-};
-use crate::error::{
-	Error as AppError,
-	Result,
-};
+use crate::config::{CommitParser, GitConfig, LinkParser, TextProcessor};
+use crate::error::{Error as AppError, Result};
 #[cfg(feature = "repo")]
-use git2::{
-	Commit as GitCommit,
-	Signature as CommitSignature,
-};
-use git_conventional::{
-	Commit as ConventionalCommit,
-	Footer as ConventionalFooter,
-};
-use lazy_regex::{
-	lazy_regex,
-	Lazy,
-	Regex,
-};
-use serde::ser::{
-	SerializeStruct,
-	Serializer,
-};
-use serde::{
-	Deserialize,
-	Serialize,
-};
+use git2::{Commit as GitCommit, Signature as CommitSignature};
+use git_conventional::{Commit as ConventionalCommit, Footer as ConventionalFooter};
+use lazy_regex::{lazy_regex, Lazy, Regex};
+use serde::ser::{SerializeStruct, Serializer};
+use serde::{Deserialize, Serialize};
 use serde_json::value::Value;
 
 /// Regular expression for matching SHA1 and a following commit message
@@ -40,755 +16,727 @@ static SHA1_REGEX: Lazy<Regex> = lazy_regex!(r#"^\b([a-f0-9]{40})\b (.*)$"#);
 #[derive(Debug, Clone, Eq, PartialEq, Deserialize, Serialize)]
 #[serde(rename_all(serialize = "camelCase"))]
 pub struct Link {
-	/// Text of the link.
-	pub text: String,
-	/// URL of the link
-	pub href: String,
+    /// Text of the link.
+    pub text: String,
+    /// URL of the link
+    pub href: String,
 }
 
 /// A conventional commit footer.
 #[derive(Debug, Clone, Eq, PartialEq, Deserialize, Serialize)]
 struct Footer<'a> {
-	/// Token of the footer.
-	///
-	/// This is the part of the footer preceding the separator. For example, for
-	/// the `Signed-off-by: <user.name>` footer, this would be `Signed-off-by`.
-	token:     &'a str,
-	/// The separator between the footer token and its value.
-	///
-	/// This is typically either `:` or `#`.
-	separator: &'a str,
-	/// The value of the footer.
-	value:     &'a str,
-	/// A flag to signal that the footer describes a breaking change.
-	breaking:  bool,
+    /// Token of the footer.
+    ///
+    /// This is the part of the footer preceding the separator. For example, for
+    /// the `Signed-off-by: <user.name>` footer, this would be `Signed-off-by`.
+    token: &'a str,
+    /// The separator between the footer token and its value.
+    ///
+    /// This is typically either `:` or `#`.
+    separator: &'a str,
+    /// The value of the footer.
+    value: &'a str,
+    /// A flag to signal that the footer describes a breaking change.
+    breaking: bool,
 }
 
 impl<'a> From<&'a ConventionalFooter<'a>> for Footer<'a> {
-	fn from(footer: &'a ConventionalFooter<'a>) -> Self {
-		Self {
-			token:     footer.token().as_str(),
-			separator: footer.separator().as_str(),
-			value:     footer.value(),
-			breaking:  footer.breaking(),
-		}
-	}
+    fn from(footer: &'a ConventionalFooter<'a>) -> Self {
+        Self {
+            token: footer.token().as_str(),
+            separator: footer.separator().as_str(),
+            value: footer.value(),
+            breaking: footer.breaking(),
+        }
+    }
 }
 
 /// Commit signature that indicates authorship.
 #[derive(Debug, Default, Clone, Eq, PartialEq, Deserialize, Serialize)]
 pub struct Signature {
-	/// Name on the signature.
-	pub name:      Option<String>,
-	/// Email on the signature.
-	pub email:     Option<String>,
-	/// Time of the signature.
-	pub timestamp: i64,
+    /// Name on the signature.
+    pub name: Option<String>,
+    /// Email on the signature.
+    pub email: Option<String>,
+    /// Time of the signature.
+    pub timestamp: i64,
 }
 
 #[cfg(feature = "repo")]
 impl<'a> From<CommitSignature<'a>> for Signature {
-	fn from(signature: CommitSignature<'a>) -> Self {
-		Self {
-			name:      signature.name().map(String::from),
-			email:     signature.email().map(String::from),
-			timestamp: signature.when().seconds(),
-		}
-	}
+    fn from(signature: CommitSignature<'a>) -> Self {
+        Self {
+            name: signature.name().map(String::from),
+            email: signature.email().map(String::from),
+            timestamp: signature.when().seconds(),
+        }
+    }
 }
 
 /// Common commit object that is parsed from a repository.
 #[derive(Debug, Default, Clone, PartialEq, Deserialize)]
 #[serde(rename_all(serialize = "camelCase"))]
 pub struct Commit<'a> {
-	/// Commit ID.
-	pub id:            String,
-	/// Commit message including title, description and summary.
-	pub message:       String,
-	/// Conventional commit.
-	#[serde(skip_deserializing)]
-	pub conv:          Option<ConventionalCommit<'a>>,
-	/// Commit group based on a commit parser or its conventional type.
-	pub group:         Option<String>,
-	/// Default commit scope based on (inherited from) conventional type or a
-	/// commit parser.
-	pub default_scope: Option<String>,
-	/// Commit scope for overriding the default one.
-	pub scope:         Option<String>,
-	/// A list of links found in the commit
-	pub links:         Vec<Link>,
-	/// Commit author.
-	pub author:        Signature,
-	/// Committer.
-	pub committer:     Signature,
-	/// Whether if the commit has two or more parents.
-	pub merge_commit:  bool,
-	/// Arbitrary data to be used with the `--from-context` CLI option.
-	pub extra:         Option<Value>,
-	/// Remote metadata of the commit.
-	pub remote:        Option<crate::contributor::RemoteContributor>,
-	/// GitHub metadata of the commit.
-	#[cfg(feature = "github")]
-	#[deprecated(note = "Use `remote` field instead")]
-	pub github:        crate::contributor::RemoteContributor,
-	/// GitLab metadata of the commit.
-	#[cfg(feature = "gitlab")]
-	#[deprecated(note = "Use `remote` field instead")]
-	pub gitlab:        crate::contributor::RemoteContributor,
-	/// Gitea metadata of the commit.
-	#[cfg(feature = "gitea")]
-	#[deprecated(note = "Use `remote` field instead")]
-	pub gitea:         crate::contributor::RemoteContributor,
-	/// Bitbucket metadata of the commit.
-	#[cfg(feature = "bitbucket")]
-	#[deprecated(note = "Use `remote` field instead")]
-	pub bitbucket:     crate::contributor::RemoteContributor,
+    /// Commit ID.
+    pub id: String,
+    /// Commit message including title, description and summary.
+    pub message: String,
+    /// Conventional commit.
+    #[serde(skip_deserializing)]
+    pub conv: Option<ConventionalCommit<'a>>,
+    /// Commit group based on a commit parser or its conventional type.
+    pub group: Option<String>,
+    /// Default commit scope based on (inherited from) conventional type or a
+    /// commit parser.
+    pub default_scope: Option<String>,
+    /// Commit scope for overriding the default one.
+    pub scope: Option<String>,
+    /// A list of links found in the commit
+    pub links: Vec<Link>,
+    /// Commit author.
+    pub author: Signature,
+    /// Committer.
+    pub committer: Signature,
+    /// Whether if the commit has two or more parents.
+    pub merge_commit: bool,
+    /// Arbitrary data to be used with the `--from-context` CLI option.
+    pub extra: Option<Value>,
+    /// Remote metadata of the commit.
+    pub remote: Option<crate::contributor::RemoteContributor>,
+    /// GitHub metadata of the commit.
+    #[cfg(feature = "github")]
+    #[deprecated(note = "Use `remote` field instead")]
+    pub github: crate::contributor::RemoteContributor,
+    /// GitLab metadata of the commit.
+    #[cfg(feature = "gitlab")]
+    #[deprecated(note = "Use `remote` field instead")]
+    pub gitlab: crate::contributor::RemoteContributor,
+    /// Gitea metadata of the commit.
+    #[cfg(feature = "gitea")]
+    #[deprecated(note = "Use `remote` field instead")]
+    pub gitea: crate::contributor::RemoteContributor,
+    /// Bitbucket metadata of the commit.
+    #[cfg(feature = "bitbucket")]
+    #[deprecated(note = "Use `remote` field instead")]
+    pub bitbucket: crate::contributor::RemoteContributor,
 }
 
 impl<'a> From<String> for Commit<'a> {
-	fn from(message: String) -> Self {
-		if let Some(captures) = SHA1_REGEX.captures(&message) {
-			if let (Some(id), Some(message)) = (
-				captures.get(1).map(|v| v.as_str()),
-				captures.get(2).map(|v| v.as_str()),
-			) {
-				return Commit {
-					id: id.to_string(),
-					message: message.to_string(),
-					..Default::default()
-				};
-			}
-		}
-		Commit {
-			id: String::new(),
-			message,
-			..Default::default()
-		}
-	}
+    fn from(message: String) -> Self {
+        if let Some(captures) = SHA1_REGEX.captures(&message) {
+            if let (Some(id), Some(message)) = (
+                captures.get(1).map(|v| v.as_str()),
+                captures.get(2).map(|v| v.as_str()),
+            ) {
+                return Commit {
+                    id: id.to_string(),
+                    message: message.to_string(),
+                    ..Default::default()
+                };
+            }
+        }
+        Commit {
+            id: String::new(),
+            message,
+            ..Default::default()
+        }
+    }
 }
 
 #[cfg(feature = "repo")]
 impl<'a> From<&GitCommit<'a>> for Commit<'a> {
-	fn from(commit: &GitCommit<'a>) -> Self {
-		Commit {
-			id: commit.id().to_string(),
-			message: commit.message().unwrap_or_default().trim_end().to_string(),
-			author: commit.author().into(),
-			committer: commit.committer().into(),
-			merge_commit: commit.parent_count() > 1,
-			..Default::default()
-		}
-	}
+    fn from(commit: &GitCommit<'a>) -> Self {
+        Commit {
+            id: commit.id().to_string(),
+            message: commit.message().unwrap_or_default().trim_end().to_string(),
+            author: commit.author().into(),
+            committer: commit.committer().into(),
+            merge_commit: commit.parent_count() > 1,
+            ..Default::default()
+        }
+    }
 }
 
 impl Commit<'_> {
-	/// Constructs a new instance.
-	pub fn new(id: String, message: String) -> Self {
-		Self {
-			id,
-			message,
-			..Default::default()
-		}
-	}
-
-	/// Processes the commit.
-	///
-	/// * converts commit to a conventional commit
-	/// * sets the group for the commit
-	/// * extracts links and generates URLs
-	pub fn process(&self, config: &GitConfig) -> Result<Self> {
-		let mut commit = self.clone();
-		if let Some(preprocessors) = &config.commit_preprocessors {
-			commit = commit.preprocess(preprocessors)?;
-		}
-		if config.conventional_commits.unwrap_or(true) {
-			if config.filter_unconventional.unwrap_or(true) &&
-				!config.split_commits.unwrap_or(false)
-			{
-				commit = commit.into_conventional()?;
-			} else if let Ok(conv_commit) = commit.clone().into_conventional() {
-				commit = conv_commit;
-			}
-		}
-		if let Some(parsers) = &config.commit_parsers {
-			commit = commit.parse(
-				parsers,
-				config.protect_breaking_commits.unwrap_or(false),
-				config.filter_commits.unwrap_or(false),
-			)?;
-		}
-		if let Some(parsers) = &config.link_parsers {
-			commit = commit.parse_links(parsers)?;
-		}
-		Ok(commit)
-	}
-
-	/// Returns the commit with its conventional type set.
-	pub fn into_conventional(mut self) -> Result<Self> {
-		match ConventionalCommit::parse(Box::leak(
-			self.message.to_string().into_boxed_str(),
-		)) {
-			Ok(conv) => {
-				self.conv = Some(conv);
-				Ok(self)
-			}
-			Err(e) => Err(AppError::ParseError(e)),
-		}
-	}
-
-	/// Preprocesses the commit using [`TextProcessor`]s.
-	///
-	/// Modifies the commit [`message`] using regex or custom OS command.
-	///
-	/// [`message`]: Commit::message
-	pub fn preprocess(mut self, preprocessors: &[TextProcessor]) -> Result<Self> {
-		preprocessors.iter().try_for_each(|preprocessor| {
-			preprocessor
-				.replace(&mut self.message, vec![("COMMIT_SHA", &self.id)])?;
-			Ok::<(), AppError>(())
-		})?;
-		Ok(self)
-	}
-
-	/// States if the commit is skipped in the provided `CommitParser`.
-	///
-	/// Returns `false` if `protect_breaking_commits` is enabled in the config
-	/// and the commit is breaking, or the parser's `skip` field is None or
-	/// `false`. Returns `true` otherwise.
-	fn skip_commit(&self, parser: &CommitParser, protect_breaking: bool) -> bool {
-		parser.skip.unwrap_or(false) &&
-			!(self.conv.as_ref().map(|c| c.breaking()).unwrap_or(false) &&
-				protect_breaking)
-	}
-
-	/// Parses the commit using [`CommitParser`]s.
-	///
-	/// Sets the [`group`] and [`scope`] of the commit.
-	///
-	/// [`group`]: Commit::group
-	/// [`scope`]: Commit::scope
-	pub fn parse(
-		mut self,
-		parsers: &[CommitParser],
-		protect_breaking: bool,
-		filter: bool,
-	) -> Result<Self> {
-		let lookup_context = serde_json::to_value(&self).map_err(|e| {
-			AppError::FieldError(format!(
-				"failed to convert context into value: {e}",
-			))
-		})?;
-		for parser in parsers {
-			let mut regex_checks = Vec::new();
-			if let Some(message_regex) = parser.message.as_ref() {
-				regex_checks.push((message_regex, self.message.to_string()));
-			}
-			let body = self
-				.conv
-				.as_ref()
-				.and_then(|v| v.body())
-				.map(|v| v.to_string());
-			if let Some(body_regex) = parser.body.as_ref() {
-				regex_checks.push((body_regex, body.clone().unwrap_or_default()));
-			}
-			if let (Some(footer_regex), Some(footers)) = (
-				parser.footer.as_ref(),
-				self.conv.as_ref().map(|v| v.footers()),
-			) {
-				regex_checks
-					.extend(footers.iter().map(|f| (footer_regex, f.to_string())));
-			}
-			if let (Some(field_name), Some(pattern_regex)) =
-				(parser.field.as_ref(), parser.pattern.as_ref())
-			{
-				let value = if field_name == "body" {
-					body.clone()
-				} else {
-					tera::dotted_pointer(&lookup_context, field_name)
-						.map(|v| v.to_string())
-				};
-				match value {
-					Some(value) => {
-						regex_checks.push((pattern_regex, value));
-					}
-					None => {
-						return Err(AppError::FieldError(format!(
-							"field {field_name} does not have a value",
-						)));
-					}
-				}
-			}
-			if parser.sha.clone().map(|v| v.to_lowercase()).as_deref() ==
-				Some(&self.id)
-			{
-				if self.skip_commit(parser, protect_breaking) {
-					return Err(AppError::GroupError(String::from(
-						"Skipping commit",
-					)));
-				} else {
-					self.group = parser.group.clone().or(self.group);
-					self.scope = parser.scope.clone().or(self.scope);
-					self.default_scope =
-						parser.default_scope.clone().or(self.default_scope);
-					return Ok(self);
-				}
-			}
-			for (regex, text) in regex_checks {
-				if regex.is_match(text.trim()) {
-					if self.skip_commit(parser, protect_breaking) {
-						return Err(AppError::GroupError(String::from(
-							"Skipping commit",
-						)));
-					} else {
-						let regex_replace = |mut value: String| {
-							for mat in regex.find_iter(&text) {
-								value =
-									regex.replace(mat.as_str(), value).to_string();
-							}
-							value
-						};
-						self.group = parser.group.clone().map(regex_replace);
-						self.scope = parser.scope.clone().map(regex_replace);
-						self.default_scope.clone_from(&parser.default_scope);
-						return Ok(self);
-					}
-				}
-			}
-		}
-		if filter {
-			Err(AppError::GroupError(String::from(
-				"Commit does not belong to any group",
-			)))
-		} else {
-			Ok(self)
-		}
-	}
-
-	/// Parses the commit using [`LinkParser`]s.
-	///
-	/// Sets the [`links`] of the commit.
-	///
-	/// [`links`]: Commit::links
-	pub fn parse_links(mut self, parsers: &[LinkParser]) -> Result<Self> {
-		for parser in parsers {
-			let regex = &parser.pattern;
-			let replace = &parser.href;
-			for mat in regex.find_iter(&self.message) {
-				let m = mat.as_str();
-				let text = if let Some(text_replace) = &parser.text {
-					regex.replace(m, text_replace).to_string()
-				} else {
-					m.to_string()
-				};
-				let href = regex.replace(m, replace);
-				self.links.push(Link {
-					text,
-					href: href.to_string(),
-				});
-			}
-		}
-		Ok(self)
-	}
-
-	/// Returns an iterator over this commit's [`Footer`]s, if this is a
-	/// conventional commit.
-	///
-	/// If this commit is not conventional, the returned iterator will be empty.
-	fn footers(&self) -> impl Iterator<Item = Footer<'_>> {
-		self.conv
-			.iter()
-			.flat_map(|conv| conv.footers().iter().map(Footer::from))
-	}
+    /// Constructs a new instance.
+    pub fn new(id: String, message: String) -> Self {
+        Self {
+            id,
+            message,
+            ..Default::default()
+        }
+    }
+
+    /// Processes the commit.
+    ///
+    /// * converts commit to a conventional commit
+    /// * sets the group for the commit
+    /// * extracts links and generates URLs
+    pub fn process(&self, config: &GitConfig) -> Result<Self> {
+        let mut commit = self.clone();
+        if let Some(preprocessors) = &config.commit_preprocessors {
+            commit = commit.preprocess(preprocessors)?;
+        }
+        if config.conventional_commits.unwrap_or(true) {
+            if config.filter_unconventional.unwrap_or(true)
+                && !config.split_commits.unwrap_or(false)
+            {
+                commit = commit.into_conventional()?;
+            } else if let Ok(conv_commit) = commit.clone().into_conventional() {
+                commit = conv_commit;
+            }
+        }
+        if let Some(parsers) = &config.commit_parsers {
+            commit = commit.parse(
+                parsers,
+                config.protect_breaking_commits.unwrap_or(false),
+                config.filter_commits.unwrap_or(false),
+            )?;
+        }
+        if let Some(parsers) = &config.link_parsers {
+            commit = commit.parse_links(parsers)?;
+        }
+        Ok(commit)
+    }
+
+    /// Returns the commit with its conventional type set.
+    pub fn into_conventional(mut self) -> Result<Self> {
+        match ConventionalCommit::parse(Box::leak(self.message.to_string().into_boxed_str())) {
+            Ok(conv) => {
+                self.conv = Some(conv);
+                Ok(self)
+            }
+            Err(e) => Err(AppError::ParseError(e)),
+        }
+    }
+
+    /// Preprocesses the commit using [`TextProcessor`]s.
+    ///
+    /// Modifies the commit [`message`] using regex or custom OS command.
+    ///
+    /// [`message`]: Commit::message
+    pub fn preprocess(mut self, preprocessors: &[TextProcessor]) -> Result<Self> {
+        preprocessors.iter().try_for_each(|preprocessor| {
+            preprocessor.replace(&mut self.message, vec![("COMMIT_SHA", &self.id)])?;
+            Ok::<(), AppError>(())
+        })?;
+        Ok(self)
+    }
+
+    /// States if the commit is skipped in the provided `CommitParser`.
+    ///
+    /// Returns `false` if `protect_breaking_commits` is enabled in the config
+    /// and the commit is breaking, or the parser's `skip` field is None or
+    /// `false`. Returns `true` otherwise.
+    fn skip_commit(&self, parser: &CommitParser, protect_breaking: bool) -> bool {
+        parser.skip.unwrap_or(false)
+            && !(self.conv.as_ref().map(|c| c.breaking()).unwrap_or(false) && protect_breaking)
+    }
+
+    /// Parses the commit using [`CommitParser`]s.
+    ///
+    /// Sets the [`group`] and [`scope`] of the commit.
+    ///
+    /// [`group`]: Commit::group
+    /// [`scope`]: Commit::scope
+    pub fn parse(
+        mut self,
+        parsers: &[CommitParser],
+        protect_breaking: bool,
+        filter: bool,
+    ) -> Result<Self> {
+        let lookup_context = serde_json::to_value(&self).map_err(|e| {
+            AppError::FieldError(format!("failed to convert context into value: {e}",))
+        })?;
+        for parser in parsers {
+            let mut regex_checks = Vec::new();
+            if let Some(message_regex) = parser.message.as_ref() {
+                regex_checks.push((message_regex, self.message.to_string()));
+            }
+            let body = self
+                .conv
+                .as_ref()
+                .and_then(|v| v.body())
+                .map(|v| v.to_string());
+            if let Some(body_regex) = parser.body.as_ref() {
+                regex_checks.push((body_regex, body.clone().unwrap_or_default()));
+            }
+            if let (Some(footer_regex), Some(footers)) = (
+                parser.footer.as_ref(),
+                self.conv.as_ref().map(|v| v.footers()),
+            ) {
+                regex_checks.extend(footers.iter().map(|f| (footer_regex, f.to_string())));
+            }
+            if let (Some(field_name), Some(pattern_regex)) =
+                (parser.field.as_ref(), parser.pattern.as_ref())
+            {
+                let value = if field_name == "body" {
+                    body.clone()
+                } else {
+                    tera::dotted_pointer(&lookup_context, field_name).map(|v| v.to_string())
+                };
+                match value {
+                    Some(value) => {
+                        regex_checks.push((pattern_regex, value));
+                    }
+                    None => {
+                        return Err(AppError::FieldError(format!(
+                            "field {field_name} does not have a value",
+                        )));
+                    }
+                }
+            }
+            if parser.sha.clone().map(|v| v.to_lowercase()).as_deref() == Some(&self.id) {
+                if self.skip_commit(parser, protect_breaking) {
+                    return Err(AppError::GroupError(String::from("Skipping commit")));
+                } else {
+                    self.group = parser.group.clone().or(self.group);
+                    self.scope = parser.scope.clone().or(self.scope);
+                    self.default_scope = parser.default_scope.clone().or(self.default_scope);
+                    return Ok(self);
+                }
+            }
+            for (regex, text) in regex_checks {
+                if regex.is_match(text.trim()) {
+                    if self.skip_commit(parser, protect_breaking) {
+                        return Err(AppError::GroupError(String::from("Skipping commit")));
+                    } else {
+                        let regex_replace = |mut value: String| {
+                            for mat in regex.find_iter(&text) {
+                                value = regex.replace(mat.as_str(), value).to_string();
+                            }
+                            value
+                        };
+                        self.group = parser.group.clone().map(regex_replace);
+                        self.scope = parser.scope.clone().map(regex_replace);
+                        self.default_scope.clone_from(&parser.default_scope);
+                        return Ok(self);
+                    }
+                }
+            }
+        }
+        if filter {
+            Err(AppError::GroupError(String::from(
+                "Commit does not belong to any group",
+            )))
+        } else {
+            Ok(self)
+        }
+    }
+
+    /// Parses the commit using [`LinkParser`]s.
+    ///
+    /// Sets the [`links`] of the commit.
+    ///
+    /// [`links`]: Commit::links
+    pub fn parse_links(mut self, parsers: &[LinkParser]) -> Result<Self> {
+        for parser in parsers {
+            let regex = &parser.pattern;
+            let replace = &parser.href;
+            for mat in regex.find_iter(&self.message) {
+                let m = mat.as_str();
+                let text = if let Some(text_replace) = &parser.text {
+                    regex.replace(m, text_replace).to_string()
+                } else {
+                    m.to_string()
+                };
+                let href = regex.replace(m, replace);
+                self.links.push(Link {
+                    text,
+                    href: href.to_string(),
+                });
+            }
+        }
+        Ok(self)
+    }
+
+    /// Returns an iterator over this commit's [`Footer`]s, if this is a
+    /// conventional commit.
+    ///
+    /// If this commit is not conventional, the returned iterator will be empty.
+    fn footers(&self) -> impl Iterator<Item = Footer<'_>> {
+        self.conv
+            .iter()
+            .flat_map(|conv| conv.footers().iter().map(Footer::from))
+    }
 }
 
 impl Serialize for Commit<'_> {
-	#[allow(deprecated)]
-	fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-	where
-		S: Serializer,
-	{
-		/// A wrapper to serialize commit footers from an iterator using
-		/// `Serializer::collect_seq` without having to allocate in order to
-		/// `collect` the footers  into a new to `Vec`.
-		struct SerializeFooters<'a>(&'a Commit<'a>);
-		impl Serialize for SerializeFooters<'_> {
-			fn serialize<S>(
-				&self,
-				serializer: S,
-			) -> std::result::Result<S::Ok, S::Error>
-			where
-				S: Serializer,
-			{
-				serializer.collect_seq(self.0.footers())
-			}
-		}
-
-		let mut commit = serializer.serialize_struct("Commit", 9)?;
-		commit.serialize_field("id", &self.id)?;
-		if let Some(conv) = &self.conv {
-			commit.serialize_field("message", conv.description())?;
-			commit.serialize_field("body", &conv.body())?;
-			commit.serialize_field("footers", &SerializeFooters(self))?;
-			commit.serialize_field(
-				"group",
-				self.group.as_ref().unwrap_or(&conv.type_().to_string()),
-			)?;
-			commit.serialize_field(
-				"breaking_description",
-				&conv.breaking_description(),
-			)?;
-			commit.serialize_field("breaking", &conv.breaking())?;
-			commit.serialize_field(
-				"scope",
-				&self
-					.scope
-					.as_deref()
-					.or_else(|| conv.scope().map(|v| v.as_str()))
-					.or(self.default_scope.as_deref()),
-			)?;
-		} else {
-			commit.serialize_field("message", &self.message)?;
-			commit.serialize_field("group", &self.group)?;
-			commit.serialize_field(
-				"scope",
-				&self.scope.as_deref().or(self.default_scope.as_deref()),
-			)?;
-		}
-
-		commit.serialize_field("links", &self.links)?;
-		commit.serialize_field("author", &self.author)?;
-		commit.serialize_field("committer", &self.committer)?;
-		commit.serialize_field("conventional", &self.conv.is_some())?;
-		commit.serialize_field("merge_commit", &self.merge_commit)?;
-		commit.serialize_field("extra", &self.extra)?;
-		#[cfg(feature = "github")]
-		commit.serialize_field("github", &self.github)?;
-		#[cfg(feature = "gitlab")]
-		commit.serialize_field("gitlab", &self.gitlab)?;
-		#[cfg(feature = "gitea")]
-		commit.serialize_field("gitea", &self.gitea)?;
-		#[cfg(feature = "bitbucket")]
-		commit.serialize_field("bitbucket", &self.bitbucket)?;
-		if let Some(remote) = &self.remote {
-			commit.serialize_field("remote", remote)?;
-		}
-		commit.end()
-	}
+    #[allow(deprecated)]
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        /// A wrapper to serialize commit footers from an iterator using
+        /// `Serializer::collect_seq` without having to allocate in order to
+        /// `collect` the footers  into a new to `Vec`.
+        struct SerializeFooters<'a>(&'a Commit<'a>);
+        impl Serialize for SerializeFooters<'_> {
+            fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+            where
+                S: Serializer,
+            {
+                serializer.collect_seq(self.0.footers())
+            }
+        }
+
+        let mut commit = serializer.serialize_struct("Commit", 9)?;
+        commit.serialize_field("id", &self.id)?;
+        if let Some(conv) = &self.conv {
+            commit.serialize_field("message", conv.description())?;
+            commit.serialize_field("body", &conv.body())?;
+            commit.serialize_field("footers", &SerializeFooters(self))?;
+            commit.serialize_field(
+                "group",
+                self.group.as_ref().unwrap_or(&conv.type_().to_string()),
+            )?;
+            commit.serialize_field("breaking_description", &conv.breaking_description())?;
+            commit.serialize_field("breaking", &conv.breaking())?;
+            commit.serialize_field(
+                "scope",
+                &self
+                    .scope
+                    .as_deref()
+                    .or_else(|| conv.scope().map(|v| v.as_str()))
+                    .or(self.default_scope.as_deref()),
+            )?;
+        } else {
+            commit.serialize_field("message", &self.message)?;
+            commit.serialize_field("group", &self.group)?;
+            commit.serialize_field(
+                "scope",
+                &self.scope.as_deref().or(self.default_scope.as_deref()),
+            )?;
+        }
+
+        commit.serialize_field("links", &self.links)?;
+        commit.serialize_field("author", &self.author)?;
+        commit.serialize_field("committer", &self.committer)?;
+        commit.serialize_field("conventional", &self.conv.is_some())?;
+        commit.serialize_field("merge_commit", &self.merge_commit)?;
+        commit.serialize_field("extra", &self.extra)?;
+        #[cfg(feature = "github")]
+        commit.serialize_field("github", &self.github)?;
+        #[cfg(feature = "gitlab")]
+        commit.serialize_field("gitlab", &self.gitlab)?;
+        #[cfg(feature = "gitea")]
+        commit.serialize_field("gitea", &self.gitea)?;
+        #[cfg(feature = "bitbucket")]
+        commit.serialize_field("bitbucket", &self.bitbucket)?;
+        if let Some(remote) = &self.remote {
+            commit.serialize_field("remote", remote)?;
+        }
+        commit.end()
+    }
 }
 
 #[cfg(test)]
 mod test {
-	use super::*;
-	#[test]
-	fn conventional_commit() -> Result<()> {
-		let test_cases = vec![
-			(
-				Commit::new(
-					String::from("123123"),
-					String::from("test(commit): add test"),
-				),
-				true,
-			),
-			(
-				Commit::new(String::from("124124"), String::from("xyz")),
-				false,
-			),
-		];
-		for (commit, is_conventional) in &test_cases {
-			assert_eq!(is_conventional, &commit.clone().into_conventional().is_ok());
-		}
-		let commit = test_cases[0].0.clone().parse(
-			&[CommitParser {
-				sha:           None,
-				message:       Regex::new("test*").ok(),
-				body:          None,
-				footer:        None,
-				group:         Some(String::from("test_group")),
-				default_scope: Some(String::from("test_scope")),
-				scope:         None,
-				skip:          None,
-				field:         None,
-				pattern:       None,
-			}],
-			false,
-			false,
-		)?;
-		assert_eq!(Some(String::from("test_group")), commit.group);
-		assert_eq!(Some(String::from("test_scope")), commit.default_scope);
-		Ok(())
-	}
-
-	#[test]
-	fn conventional_footers() {
-		let cfg = crate::config::GitConfig {
-			conventional_commits: Some(true),
-			..Default::default()
-		};
-		let test_cases = vec![
-			(
-				Commit::new(
-					String::from("123123"),
-					String::from(
-						"test(commit): add test\n\nSigned-off-by: Test User \
+    use super::*;
+    #[test]
+    fn conventional_commit() -> Result<()> {
+        let test_cases = vec![
+            (
+                Commit::new(
+                    String::from("123123"),
+                    String::from("test(commit): add test"),
+                ),
+                true,
+            ),
+            (
+                Commit::new(String::from("124124"), String::from("xyz")),
+                false,
+            ),
+        ];
+        for (commit, is_conventional) in &test_cases {
+            assert_eq!(is_conventional, &commit.clone().into_conventional().is_ok());
+        }
+        let commit = test_cases[0].0.clone().parse(
+            &[CommitParser {
+                sha: None,
+                message: Regex::new("test*").ok(),
+                body: None,
+                footer: None,
+                group: Some(String::from("test_group")),
+                default_scope: Some(String::from("test_scope")),
+                scope: None,
+                skip: None,
+                field: None,
+                pattern: None,
+            }],
+            false,
+            false,
+        )?;
+        assert_eq!(Some(String::from("test_group")), commit.group);
+        assert_eq!(Some(String::from("test_scope")), commit.default_scope);
+        Ok(())
+    }
+
+    #[test]
+    fn conventional_footers() {
+        let cfg = crate::config::GitConfig {
+            conventional_commits: Some(true),
+            ..Default::default()
+        };
+        let test_cases = vec![
+            (
+                Commit::new(
+                    String::from("123123"),
+                    String::from(
+                        "test(commit): add test\n\nSigned-off-by: Test User \
 						 <test@example.com>",
-					),
-				),
-				vec![Footer {
-					token:     "Signed-off-by",
-					separator: ":",
-					value:     "Test User <test@example.com>",
-					breaking:  false,
-				}],
-			),
-			(
-				Commit::new(
-					String::from("123124"),
-					String::from(
-						"fix(commit): break stuff\n\nBREAKING CHANGE: This commit \
+                    ),
+                ),
+                vec![Footer {
+                    token: "Signed-off-by",
+                    separator: ":",
+                    value: "Test User <test@example.com>",
+                    breaking: false,
+                }],
+            ),
+            (
+                Commit::new(
+                    String::from("123124"),
+                    String::from(
+                        "fix(commit): break stuff\n\nBREAKING CHANGE: This commit \
 						 breaks stuff\nSigned-off-by: Test User <test@example.com>",
-					),
-				),
-				vec![
-					Footer {
-						token:     "BREAKING CHANGE",
-						separator: ":",
-						value:     "This commit breaks stuff",
-						breaking:  true,
-					},
-					Footer {
-						token:     "Signed-off-by",
-						separator: ":",
-						value:     "Test User <test@example.com>",
-						breaking:  false,
-					},
-				],
-			),
-		];
-		for (commit, footers) in &test_cases {
-			let commit = commit.process(&cfg).expect("commit should process");
-			assert_eq!(&commit.footers().collect::<Vec<_>>(), footers);
-		}
-	}
-
-	#[test]
-	fn parse_link() -> Result<()> {
-		let test_cases = vec![
-			(
-				Commit::new(
-					String::from("123123"),
-					String::from("test(commit): add test\n\nBody with issue #123"),
-				),
-				true,
-			),
-			(
-				Commit::new(
-					String::from("123123"),
-					String::from(
-						"test(commit): add test\n\nImlement RFC456\n\nFixes: #456",
-					),
-				),
-				true,
-			),
-		];
-		for (commit, is_conventional) in &test_cases {
-			assert_eq!(is_conventional, &commit.clone().into_conventional().is_ok());
-		}
-		let commit = Commit::new(
-			String::from("123123"),
-			String::from("test(commit): add test\n\nImlement RFC456\n\nFixes: #455"),
-		);
-		let commit = commit.parse_links(&[
-			LinkParser {
-				pattern: Regex::new("RFC(\\d+)")?,
-				href:    String::from("rfc://$1"),
-				text:    None,
-			},
-			LinkParser {
-				pattern: Regex::new("#(\\d+)")?,
-				href:    String::from("https://github.com/$1"),
-				text:    None,
-			},
-		])?;
-		assert_eq!(
-			vec![
-				Link {
-					text: String::from("RFC456"),
-					href: String::from("rfc://456"),
-				},
-				Link {
-					text: String::from("#455"),
-					href: String::from("https://github.com/455"),
-				}
-			],
-			commit.links
-		);
-		Ok(())
-	}
-
-	#[test]
-	fn parse_commit() {
-		assert_eq!(
-			Commit::new(String::new(), String::from("test: no sha1 given")),
-			Commit::from(String::from("test: no sha1 given"))
-		);
-		assert_eq!(
-			Commit::new(
-				String::from("8f55e69eba6e6ce811ace32bd84cc82215673cb6"),
-				String::from("feat: do something")
-			),
-			Commit::from(String::from(
-				"8f55e69eba6e6ce811ace32bd84cc82215673cb6 feat: do something"
-			))
-		);
-		assert_eq!(
-			Commit::new(
-				String::from("3bdd0e690c4cd5bd00e5201cc8ef3ce3fb235853"),
-				String::from("chore: do something")
-			),
-			Commit::from(String::from(
-				"3bdd0e690c4cd5bd00e5201cc8ef3ce3fb235853 chore: do something"
-			))
-		);
-		assert_eq!(
-			Commit::new(
-				String::new(),
-				String::from("thisisinvalidsha1 style: add formatting")
-			),
-			Commit::from(String::from("thisisinvalidsha1 style: add formatting"))
-		);
-	}
-
-	#[test]
-	fn parse_commit_field() -> Result<()> {
-		let mut commit = Commit::new(
-			String::from("8f55e69eba6e6ce811ace32bd84cc82215673cb6"),
-			String::from("feat: do something"),
-		);
-
-		commit.author = Signature {
-			name:      Some("John Doe".to_string()),
-			email:     None,
-			timestamp: 0x0,
-		};
-
-		let parsed_commit = commit.parse(
-			&[CommitParser {
-				sha:           None,
-				message:       None,
-				body:          None,
-				footer:        None,
-				group:         Some(String::from("Test group")),
-				default_scope: None,
-				scope:         None,
-				skip:          None,
-				field:         Some(String::from("author.name")),
-				pattern:       Regex::new("John Doe").ok(),
-			}],
-			false,
-			false,
-		)?;
-
-		assert_eq!(Some(String::from("Test group")), parsed_commit.group);
-		Ok(())
-	}
-
-	#[test]
-	fn commit_sha() -> Result<()> {
-		let commit = Commit::new(
-			String::from("8f55e69eba6e6ce811ace32bd84cc82215673cb6"),
-			String::from("feat: do something"),
-		);
-		let parsed_commit = commit.clone().parse(
-			&[CommitParser {
-				sha:           Some(String::from(
-					"8f55e69eba6e6ce811ace32bd84cc82215673cb6",
-				)),
-				message:       None,
-				body:          None,
-				footer:        None,
-				group:         None,
-				default_scope: None,
-				scope:         None,
-				skip:          Some(true),
-				field:         None,
-				pattern:       None,
-			}],
-			false,
-			false,
-		);
-		assert!(parsed_commit.is_err());
-
-		let parsed_commit = commit.parse(
-			&[CommitParser {
-				sha:           Some(String::from(
-					"8f55e69eba6e6ce811ace32bd84cc82215673cb6",
-				)),
-				message:       None,
-				body:          None,
-				footer:        None,
-				group:         Some(String::from("Test group")),
-				default_scope: None,
-				scope:         None,
-				skip:          None,
-				field:         None,
-				pattern:       None,
-			}],
-			false,
-			false,
-		)?;
-		assert_eq!(Some(String::from("Test group")), parsed_commit.group);
-
-		Ok(())
-	}
-
-	#[test]
-	fn field_name_regex() -> Result<()> {
-		let commit = Commit {
-			message: String::from("feat: do something"),
-			author: Signature {
-				name:      Some("John Doe".to_string()),
-				email:     None,
-				timestamp: 0x0,
-			},
-			..Default::default()
-		};
-		let parsed_commit = commit.clone().parse(
-			&[CommitParser {
-				sha:           None,
-				message:       None,
-				body:          None,
-				footer:        None,
-				group:         Some(String::from("Test group")),
-				default_scope: None,
-				scope:         None,
-				skip:          None,
-				field:         Some(String::from("author.name")),
-				pattern:       Regex::new("Something else").ok(),
-			}],
-			false,
-			true,
-		);
-
-		assert!(parsed_commit.is_err());
-
-		let parsed_commit = commit.parse(
-			&[CommitParser {
-				sha:           None,
-				message:       None,
-				body:          None,
-				footer:        None,
-				group:         Some(String::from("Test group")),
-				default_scope: None,
-				scope:         None,
-				skip:          None,
-				field:         Some(String::from("author.name")),
-				pattern:       Regex::new("John Doe").ok(),
-			}],
-			false,
-			false,
-		)?;
-
-		assert_eq!(Some(String::from("Test group")), parsed_commit.group);
-		Ok(())
-	}
+                    ),
+                ),
+                vec![
+                    Footer {
+                        token: "BREAKING CHANGE",
+                        separator: ":",
+                        value: "This commit breaks stuff",
+                        breaking: true,
+                    },
+                    Footer {
+                        token: "Signed-off-by",
+                        separator: ":",
+                        value: "Test User <test@example.com>",
+                        breaking: false,
+                    },
+                ],
+            ),
+        ];
+        for (commit, footers) in &test_cases {
+            let commit = commit.process(&cfg).expect("commit should process");
+            assert_eq!(&commit.footers().collect::<Vec<_>>(), footers);
+        }
+    }
+
+    #[test]
+    fn parse_link() -> Result<()> {
+        let test_cases = vec![
+            (
+                Commit::new(
+                    String::from("123123"),
+                    String::from("test(commit): add test\n\nBody with issue #123"),
+                ),
+                true,
+            ),
+            (
+                Commit::new(
+                    String::from("123123"),
+                    String::from("test(commit): add test\n\nImlement RFC456\n\nFixes: #456"),
+                ),
+                true,
+            ),
+        ];
+        for (commit, is_conventional) in &test_cases {
+            assert_eq!(is_conventional, &commit.clone().into_conventional().is_ok());
+        }
+        let commit = Commit::new(
+            String::from("123123"),
+            String::from("test(commit): add test\n\nImlement RFC456\n\nFixes: #455"),
+        );
+        let commit = commit.parse_links(&[
+            LinkParser {
+                pattern: Regex::new("RFC(\\d+)")?,
+                href: String::from("rfc://$1"),
+                text: None,
+            },
+            LinkParser {
+                pattern: Regex::new("#(\\d+)")?,
+                href: String::from("https://github.com/$1"),
+                text: None,
+            },
+        ])?;
+        assert_eq!(
+            vec![
+                Link {
+                    text: String::from("RFC456"),
+                    href: String::from("rfc://456"),
+                },
+                Link {
+                    text: String::from("#455"),
+                    href: String::from("https://github.com/455"),
+                }
+            ],
+            commit.links
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn parse_commit() {
+        assert_eq!(
+            Commit::new(String::new(), String::from("test: no sha1 given")),
+            Commit::from(String::from("test: no sha1 given"))
+        );
+        assert_eq!(
+            Commit::new(
+                String::from("8f55e69eba6e6ce811ace32bd84cc82215673cb6"),
+                String::from("feat: do something")
+            ),
+            Commit::from(String::from(
+                "8f55e69eba6e6ce811ace32bd84cc82215673cb6 feat: do something"
+            ))
+        );
+        assert_eq!(
+            Commit::new(
+                String::from("3bdd0e690c4cd5bd00e5201cc8ef3ce3fb235853"),
+                String::from("chore: do something")
+            ),
+            Commit::from(String::from(
+                "3bdd0e690c4cd5bd00e5201cc8ef3ce3fb235853 chore: do something"
+            ))
+        );
+        assert_eq!(
+            Commit::new(
+                String::new(),
+                String::from("thisisinvalidsha1 style: add formatting")
+            ),
+            Commit::from(String::from("thisisinvalidsha1 style: add formatting"))
+        );
+    }
+
+    #[test]
+    fn parse_commit_field() -> Result<()> {
+        let mut commit = Commit::new(
+            String::from("8f55e69eba6e6ce811ace32bd84cc82215673cb6"),
+            String::from("feat: do something"),
+        );
+
+        commit.author = Signature {
+            name: Some("John Doe".to_string()),
+            email: None,
+            timestamp: 0x0,
+        };
+
+        let parsed_commit = commit.parse(
+            &[CommitParser {
+                sha: None,
+                message: None,
+                body: None,
+                footer: None,
+                group: Some(String::from("Test group")),
+                default_scope: None,
+                scope: None,
+                skip: None,
+                field: Some(String::from("author.name")),
+                pattern: Regex::new("John Doe").ok(),
+            }],
+            false,
+            false,
+        )?;
+
+        assert_eq!(Some(String::from("Test group")), parsed_commit.group);
+        Ok(())
+    }
+
+    #[test]
+    fn commit_sha() -> Result<()> {
+        let commit = Commit::new(
+            String::from("8f55e69eba6e6ce811ace32bd84cc82215673cb6"),
+            String::from("feat: do something"),
+        );
+        let parsed_commit = commit.clone().parse(
+            &[CommitParser {
+                sha: Some(String::from("8f55e69eba6e6ce811ace32bd84cc82215673cb6")),
+                message: None,
+                body: None,
+                footer: None,
+                group: None,
+                default_scope: None,
+                scope: None,
+                skip: Some(true),
+                field: None,
+                pattern: None,
+            }],
+            false,
+            false,
+        );
+        assert!(parsed_commit.is_err());
+
+        let parsed_commit = commit.parse(
+            &[CommitParser {
+                sha: Some(String::from("8f55e69eba6e6ce811ace32bd84cc82215673cb6")),
+                message: None,
+                body: None,
+                footer: None,
+                group: Some(String::from("Test group")),
+                default_scope: None,
+                scope: None,
+                skip: None,
+                field: None,
+                pattern: None,
+            }],
+            false,
+            false,
+        )?;
+        assert_eq!(Some(String::from("Test group")), parsed_commit.group);
+
+        Ok(())
+    }
+
+    #[test]
+    fn field_name_regex() -> Result<()> {
+        let commit = Commit {
+            message: String::from("feat: do something"),
+            author: Signature {
+                name: Some("John Doe".to_string()),
+                email: None,
+                timestamp: 0x0,
+            },
+            ..Default::default()
+        };
+        let parsed_commit = commit.clone().parse(
+            &[CommitParser {
+                sha: None,
+                message: None,
+                body: None,
+                footer: None,
+                group: Some(String::from("Test group")),
+                default_scope: None,
+                scope: None,
+                skip: None,
+                field: Some(String::from("author.name")),
+                pattern: Regex::new("Something else").ok(),
+            }],
+            false,
+            true,
+        );
+
+        assert!(parsed_commit.is_err());
+
+        let parsed_commit = commit.parse(
+            &[CommitParser {
+                sha: None,
+                message: None,
+                body: None,
+                footer: None,
+                group: Some(String::from("Test group")),
+                default_scope: None,
+                scope: None,
+                skip: None,
+                field: Some(String::from("author.name")),
+                pattern: Regex::new("John Doe").ok(),
+            }],
+            false,
+            false,
+        )?;
+
+        assert_eq!(Some(String::from("Test group")), parsed_commit.group);
+        Ok(())
+    }
 }
diff --git a/git-cliff-core/src/config.rs b/git-cliff-core/src/config.rs
index 2266bb3444..99fbcce25f 100644
--- a/git-cliff-core/src/config.rs
+++ b/git-cliff-core/src/config.rs
@@ -1,14 +1,8 @@
 use crate::command;
 use crate::error::Result;
-use regex::{
-	Regex,
-	RegexBuilder,
-};
+use regex::{Regex, RegexBuilder};
 use secrecy::SecretString;
-use serde::{
-	Deserialize,
-	Serialize,
-};
+use serde::{Deserialize, Serialize};
 use std::fmt;
 use std::fs;
 use std::path::Path;
@@ -20,456 +14,443 @@ const DEFAULT_INITIAL_TAG: &str = "0.1.0";
 /// Manifest file information and regex for matching contents.
 #[derive(Debug)]
 struct ManifestInfo {
-	/// Path of the manifest.
-	path:  PathBuf,
-	/// Regular expression for matching metadata in the manifest.
-	regex: Regex,
+    /// Path of the manifest.
+    path: PathBuf,
+    /// Regular expression for matching metadata in the manifest.
+    regex: Regex,
 }
 
 lazy_static::lazy_static! {
-	/// Array containing manifest information for Rust and Python projects.
-	static ref MANIFEST_INFO: Vec<ManifestInfo> = vec![
-		ManifestInfo {
-			path: PathBuf::from("Cargo.toml"),
-			regex: RegexBuilder::new(
-				r"^\[(?:workspace|package)\.metadata\.git\-cliff\.",
-			)
-			.multi_line(true)
-			.build()
-			.expect("failed to build regex"),
-		},
-		ManifestInfo {
-			path: PathBuf::from("pyproject.toml"),
-			regex: RegexBuilder::new(r"^\[(?:tool)\.git\-cliff\.")
-				.multi_line(true)
-				.build()
-				.expect("failed to build regex"),
-		},
-	];
+    /// Array containing manifest information for Rust and Python projects.
+    static ref MANIFEST_INFO: Vec<ManifestInfo> = vec![
+        ManifestInfo {
+            path: PathBuf::from("Cargo.toml"),
+            regex: RegexBuilder::new(
+                r"^\[(?:workspace|package)\.metadata\.git\-cliff\.",
+            )
+            .multi_line(true)
+            .build()
+            .expect("failed to build regex"),
+        },
+        ManifestInfo {
+            path: PathBuf::from("pyproject.toml"),
+            regex: RegexBuilder::new(r"^\[(?:tool)\.git\-cliff\.")
+                .multi_line(true)
+                .build()
+                .expect("failed to build regex"),
+        },
+    ];
 
 }
 
 /// Configuration values.
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct Config {
-	/// Configuration values about changelog generation.
-	#[serde(default)]
-	pub changelog: ChangelogConfig,
-	/// Configuration values about git.
-	#[serde(default)]
-	pub git:       GitConfig,
-	/// Configuration values about remote.
-	#[serde(default)]
-	pub remote:    RemoteConfig,
-	/// Configuration values about bump version.
-	#[serde(default)]
-	pub bump:      Bump,
+    /// Configuration values about changelog generation.
+    #[serde(default)]
+    pub changelog: ChangelogConfig,
+    /// Configuration values about git.
+    #[serde(default)]
+    pub git: GitConfig,
+    /// Configuration values about remote.
+    #[serde(default)]
+    pub remote: RemoteConfig,
+    /// Configuration values about bump version.
+    #[serde(default)]
+    pub bump: Bump,
 }
 
 /// Changelog configuration.
 #[derive(Debug, Default, Clone, Serialize, Deserialize)]
 pub struct ChangelogConfig {
-	/// Changelog header.
-	pub header:         Option<String>,
-	/// Changelog body, template.
-	pub body:           Option<String>,
-	/// Changelog footer.
-	pub footer:         Option<String>,
-	/// Trim the template.
-	pub trim:           Option<bool>,
-	/// Always render the body template.
-	pub render_always:  Option<bool>,
-	/// Changelog postprocessors.
-	pub postprocessors: Option<Vec<TextProcessor>>,
-	/// Output file path.
-	pub output:         Option<PathBuf>,
+    /// Changelog header.
+    pub header: Option<String>,
+    /// Changelog body, template.
+    pub body: Option<String>,
+    /// Changelog footer.
+    pub footer: Option<String>,
+    /// Trim the template.
+    pub trim: Option<bool>,
+    /// Always render the body template.
+    pub render_always: Option<bool>,
+    /// Changelog postprocessors.
+    pub postprocessors: Option<Vec<TextProcessor>>,
+    /// Output file path.
+    pub output: Option<PathBuf>,
 }
 
 /// Git configuration
 #[derive(Debug, Default, Clone, Serialize, Deserialize)]
 pub struct GitConfig {
-	/// Whether to enable parsing conventional commits.
-	pub conventional_commits:  Option<bool>,
-	/// Whether to filter out unconventional commits.
-	pub filter_unconventional: Option<bool>,
-	/// Whether to split commits by line, processing each line as an individual
-	/// commit.
-	pub split_commits:         Option<bool>,
-
-	/// Git commit preprocessors.
-	pub commit_preprocessors:     Option<Vec<TextProcessor>>,
-	/// Git commit parsers.
-	pub commit_parsers:           Option<Vec<CommitParser>>,
-	/// Whether to protect all breaking changes from being skipped by a commit
-	/// parser.
-	pub protect_breaking_commits: Option<bool>,
-	/// Link parsers.
-	pub link_parsers:             Option<Vec<LinkParser>>,
-	/// Whether to filter out commits.
-	pub filter_commits:           Option<bool>,
-	/// Blob pattern for git tags.
-	#[serde(with = "serde_regex", default)]
-	pub tag_pattern:              Option<Regex>,
-	/// Regex to skip matched tags.
-	#[serde(with = "serde_regex", default)]
-	pub skip_tags:                Option<Regex>,
-	/// Regex to ignore matched tags.
-	#[serde(with = "serde_regex", default)]
-	pub ignore_tags:              Option<Regex>,
-	/// Regex to count matched tags.
-	#[serde(with = "serde_regex", default)]
-	pub count_tags:               Option<Regex>,
-	/// Include only the tags that belong to the current branch.
-	pub use_branch_tags:          Option<bool>,
-	/// Whether to sort tags topologically.
-	pub topo_order:               Option<bool>,
-	/// Sorting of the commits inside sections.
-	pub sort_commits:             Option<String>,
-	/// Limit the number of commits included in the changelog.
-	pub limit_commits:            Option<usize>,
+    /// Whether to enable parsing conventional commits.
+    pub conventional_commits: Option<bool>,
+    /// Whether to filter out unconventional commits.
+    pub filter_unconventional: Option<bool>,
+    /// Whether to split commits by line, processing each line as an individual
+    /// commit.
+    pub split_commits: Option<bool>,
+
+    /// Git commit preprocessors.
+    pub commit_preprocessors: Option<Vec<TextProcessor>>,
+    /// Git commit parsers.
+    pub commit_parsers: Option<Vec<CommitParser>>,
+    /// Whether to protect all breaking changes from being skipped by a commit
+    /// parser.
+    pub protect_breaking_commits: Option<bool>,
+    /// Link parsers.
+    pub link_parsers: Option<Vec<LinkParser>>,
+    /// Whether to filter out commits.
+    pub filter_commits: Option<bool>,
+    /// Blob pattern for git tags.
+    #[serde(with = "serde_regex", default)]
+    pub tag_pattern: Option<Regex>,
+    /// Regex to skip matched tags.
+    #[serde(with = "serde_regex", default)]
+    pub skip_tags: Option<Regex>,
+    /// Regex to ignore matched tags.
+    #[serde(with = "serde_regex", default)]
+    pub ignore_tags: Option<Regex>,
+    /// Regex to count matched tags.
+    #[serde(with = "serde_regex", default)]
+    pub count_tags: Option<Regex>,
+    /// Include only the tags that belong to the current branch.
+    pub use_branch_tags: Option<bool>,
+    /// Whether to sort tags topologically.
+    pub topo_order: Option<bool>,
+    /// Sorting of the commits inside sections.
+    pub sort_commits: Option<String>,
+    /// Limit the number of commits included in the changelog.
+    pub limit_commits: Option<usize>,
 }
 
 /// Remote configuration.
 #[derive(Default, Debug, Clone, Serialize, Deserialize)]
 pub struct RemoteConfig {
-	/// GitHub remote.
-	#[serde(default)]
-	pub github:    Remote,
-	/// GitLab remote.
-	#[serde(default)]
-	pub gitlab:    Remote,
-	/// Gitea remote.
-	#[serde(default)]
-	pub gitea:     Remote,
-	/// Bitbucket remote.
-	#[serde(default)]
-	pub bitbucket: Remote,
+    /// GitHub remote.
+    #[serde(default)]
+    pub github: Remote,
+    /// GitLab remote.
+    #[serde(default)]
+    pub gitlab: Remote,
+    /// Gitea remote.
+    #[serde(default)]
+    pub gitea: Remote,
+    /// Bitbucket remote.
+    #[serde(default)]
+    pub bitbucket: Remote,
 }
 
 impl RemoteConfig {
-	/// Returns `true` if any remote is set.
-	pub fn is_any_set(&self) -> bool {
-		#[cfg(feature = "github")]
-		if self.github.is_set() {
-			return true;
-		}
-		#[cfg(feature = "gitlab")]
-		if self.gitlab.is_set() {
-			return true;
-		}
-		#[cfg(feature = "gitea")]
-		if self.gitea.is_set() {
-			return true;
-		}
-		#[cfg(feature = "bitbucket")]
-		if self.bitbucket.is_set() {
-			return true;
-		}
-		false
-	}
+    /// Returns `true` if any remote is set.
+    pub fn is_any_set(&self) -> bool {
+        #[cfg(feature = "github")]
+        if self.github.is_set() {
+            return true;
+        }
+        #[cfg(feature = "gitlab")]
+        if self.gitlab.is_set() {
+            return true;
+        }
+        #[cfg(feature = "gitea")]
+        if self.gitea.is_set() {
+            return true;
+        }
+        #[cfg(feature = "bitbucket")]
+        if self.bitbucket.is_set() {
+            return true;
+        }
+        false
+    }
 }
 
 /// A single remote.
 #[derive(Debug, Default, Clone, Serialize, Deserialize)]
 pub struct Remote {
-	/// Owner of the remote.
-	pub owner:     String,
-	/// Repository name.
-	pub repo:      String,
-	/// Access token.
-	#[serde(skip_serializing)]
-	pub token:     Option<SecretString>,
-	/// Whether if the remote is set manually.
-	#[serde(skip_deserializing, default = "default_true")]
-	pub is_custom: bool,
+    /// Owner of the remote.
+    pub owner: String,
+    /// Repository name.
+    pub repo: String,
+    /// Access token.
+    #[serde(skip_serializing)]
+    pub token: Option<SecretString>,
+    /// Whether if the remote is set manually.
+    #[serde(skip_deserializing, default = "default_true")]
+    pub is_custom: bool,
 }
 
 /// Returns `true` for serde's `default` attribute.
 fn default_true() -> bool {
-	true
+    true
 }
 
 impl fmt::Display for Remote {
-	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-		write!(f, "{}/{}", self.owner, self.repo)
-	}
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}/{}", self.owner, self.repo)
+    }
 }
 
 impl PartialEq for Remote {
-	fn eq(&self, other: &Self) -> bool {
-		self.to_string() == other.to_string()
-	}
+    fn eq(&self, other: &Self) -> bool {
+        self.to_string() == other.to_string()
+    }
 }
 
 impl Remote {
-	/// Constructs a new instance.
-	pub fn new<S: Into<String>>(owner: S, repo: S) -> Self {
-		Self {
-			owner:     owner.into(),
-			repo:      repo.into(),
-			token:     None,
-			is_custom: false,
-		}
-	}
-
-	/// Returns `true` if the remote has an owner and repo.
-	pub fn is_set(&self) -> bool {
-		!self.owner.is_empty() && !self.repo.is_empty()
-	}
+    /// Constructs a new instance.
+    pub fn new<S: Into<String>>(owner: S, repo: S) -> Self {
+        Self {
+            owner: owner.into(),
+            repo: repo.into(),
+            token: None,
+            is_custom: false,
+        }
+    }
+
+    /// Returns `true` if the remote has an owner and repo.
+    pub fn is_set(&self) -> bool {
+        !self.owner.is_empty() && !self.repo.is_empty()
+    }
 }
 
 /// Version bump type.
 #[derive(Debug, Clone, Copy, Serialize, Deserialize, Eq, PartialEq)]
 pub enum BumpType {
-	/// Bump major version.
-	Major,
-	/// Bump minor version.
-	Minor,
-	/// Bump patch version.
-	Patch,
+    /// Bump major version.
+    Major,
+    /// Bump minor version.
+    Minor,
+    /// Bump patch version.
+    Patch,
 }
 
 /// Bump version configuration.
 #[derive(Debug, Default, Clone, Serialize, Deserialize)]
 pub struct Bump {
-	/// Configures automatic minor version increments for feature changes.
-	///
-	/// When `true`, a feature will always trigger a minor version update.
-	/// When `false`, a feature will trigger:
-	///
-	/// - A patch version update if the major version is 0.
-	/// - A minor version update otherwise.
-	pub features_always_bump_minor: Option<bool>,
-
-	/// Configures 0 -> 1 major version increments for breaking changes.
-	///
-	/// When `true`, a breaking change commit will always trigger a major
-	/// version update (including the transition from version 0 to 1)
-	/// When `false`, a breaking change commit will trigger:
-	///
-	/// - A minor version update if the major version is 0.
-	/// - A major version update otherwise.
-	pub breaking_always_bump_major: Option<bool>,
-
-	/// Configures the initial version of the project.
-	///
-	/// When set, the version will be set to this value if no tags are found.
-	pub initial_tag: Option<String>,
-
-	/// Configure a custom regex pattern for major version increments.
-	///
-	/// This will check only the type of the commit against the given pattern.
-	///
-	/// ### Note
-	///
-	/// `commit type` according to the spec is only `[a-zA-Z]+`
-	pub custom_major_increment_regex: Option<String>,
-
-	/// Configure a custom regex pattern for minor version increments.
-	///
-	/// This will check only the type of the commit against the given pattern.
-	///
-	/// ### Note
-	///
-	/// `commit type` according to the spec is only `[a-zA-Z]+`
-	pub custom_minor_increment_regex: Option<String>,
-
-	/// Force to always bump in major, minor or patch.
-	pub bump_type: Option<BumpType>,
+    /// Configures automatic minor version increments for feature changes.
+    ///
+    /// When `true`, a feature will always trigger a minor version update.
+    /// When `false`, a feature will trigger:
+    ///
+    /// - A patch version update if the major version is 0.
+    /// - A minor version update otherwise.
+    pub features_always_bump_minor: Option<bool>,
+
+    /// Configures 0 -> 1 major version increments for breaking changes.
+    ///
+    /// When `true`, a breaking change commit will always trigger a major
+    /// version update (including the transition from version 0 to 1)
+    /// When `false`, a breaking change commit will trigger:
+    ///
+    /// - A minor version update if the major version is 0.
+    /// - A major version update otherwise.
+    pub breaking_always_bump_major: Option<bool>,
+
+    /// Configures the initial version of the project.
+    ///
+    /// When set, the version will be set to this value if no tags are found.
+    pub initial_tag: Option<String>,
+
+    /// Configure a custom regex pattern for major version increments.
+    ///
+    /// This will check only the type of the commit against the given pattern.
+    ///
+    /// ### Note
+    ///
+    /// `commit type` according to the spec is only `[a-zA-Z]+`
+    pub custom_major_increment_regex: Option<String>,
+
+    /// Configure a custom regex pattern for minor version increments.
+    ///
+    /// This will check only the type of the commit against the given pattern.
+    ///
+    /// ### Note
+    ///
+    /// `commit type` according to the spec is only `[a-zA-Z]+`
+    pub custom_minor_increment_regex: Option<String>,
+
+    /// Force to always bump in major, minor or patch.
+    pub bump_type: Option<BumpType>,
 }
 
 impl Bump {
-	/// Returns the initial tag.
-	///
-	/// This function also logs the returned value.
-	pub fn get_initial_tag(&self) -> String {
-		if let Some(tag) = self.initial_tag.clone() {
-			warn!(
-				"No releases found, using initial tag '{tag}' as the next version."
-			);
-			tag
-		} else {
-			warn!(
-				"No releases found, using {DEFAULT_INITIAL_TAG} as the next \
+    /// Returns the initial tag.
+    ///
+    /// This function also logs the returned value.
+    pub fn get_initial_tag(&self) -> String {
+        if let Some(tag) = self.initial_tag.clone() {
+            warn!("No releases found, using initial tag '{tag}' as the next version.");
+            tag
+        } else {
+            warn!(
+                "No releases found, using {DEFAULT_INITIAL_TAG} as the next \
 				 version."
-			);
-			DEFAULT_INITIAL_TAG.into()
-		}
-	}
+            );
+            DEFAULT_INITIAL_TAG.into()
+        }
+    }
 }
 
 /// Parser for grouping commits.
 #[derive(Debug, Default, Clone, Serialize, Deserialize)]
 pub struct CommitParser {
-	/// SHA1 of the commit.
-	pub sha:           Option<String>,
-	/// Regex for matching the commit message.
-	#[serde(with = "serde_regex", default)]
-	pub message:       Option<Regex>,
-	/// Regex for matching the commit body.
-	#[serde(with = "serde_regex", default)]
-	pub body:          Option<Regex>,
-	/// Regex for matching the commit footer.
-	#[serde(with = "serde_regex", default)]
-	pub footer:        Option<Regex>,
-	/// Group of the commit.
-	pub group:         Option<String>,
-	/// Default scope of the commit.
-	pub default_scope: Option<String>,
-	/// Commit scope for overriding the default scope.
-	pub scope:         Option<String>,
-	/// Whether to skip this commit group.
-	pub skip:          Option<bool>,
-	/// Field name of the commit to match the regex against.
-	pub field:         Option<String>,
-	/// Regex for matching the field value.
-	#[serde(with = "serde_regex", default)]
-	pub pattern:       Option<Regex>,
+    /// SHA1 of the commit.
+    pub sha: Option<String>,
+    /// Regex for matching the commit message.
+    #[serde(with = "serde_regex", default)]
+    pub message: Option<Regex>,
+    /// Regex for matching the commit body.
+    #[serde(with = "serde_regex", default)]
+    pub body: Option<Regex>,
+    /// Regex for matching the commit footer.
+    #[serde(with = "serde_regex", default)]
+    pub footer: Option<Regex>,
+    /// Group of the commit.
+    pub group: Option<String>,
+    /// Default scope of the commit.
+    pub default_scope: Option<String>,
+    /// Commit scope for overriding the default scope.
+    pub scope: Option<String>,
+    /// Whether to skip this commit group.
+    pub skip: Option<bool>,
+    /// Field name of the commit to match the regex against.
+    pub field: Option<String>,
+    /// Regex for matching the field value.
+    #[serde(with = "serde_regex", default)]
+    pub pattern: Option<Regex>,
 }
 
 /// `TextProcessor`, e.g. for modifying commit messages.
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct TextProcessor {
-	/// Regex for matching a text to replace.
-	#[serde(with = "serde_regex")]
-	pub pattern:         Regex,
-	/// Replacement text.
-	pub replace:         Option<String>,
-	/// Command that will be run for replacing the commit message.
-	pub replace_command: Option<String>,
+    /// Regex for matching a text to replace.
+    #[serde(with = "serde_regex")]
+    pub pattern: Regex,
+    /// Replacement text.
+    pub replace: Option<String>,
+    /// Command that will be run for replacing the commit message.
+    pub replace_command: Option<String>,
 }
 
 impl TextProcessor {
-	/// Replaces the text with using the given pattern or the command output.
-	pub fn replace(
-		&self,
-		rendered: &mut String,
-		command_envs: Vec<(&str, &str)>,
-	) -> Result<()> {
-		if let Some(text) = &self.replace {
-			*rendered = self.pattern.replace_all(rendered, text).to_string();
-		} else if let Some(command) = &self.replace_command {
-			if self.pattern.is_match(rendered) {
-				*rendered =
-					command::run(command, Some(rendered.to_string()), command_envs)?;
-			}
-		}
-		Ok(())
-	}
+    /// Replaces the text with using the given pattern or the command output.
+    pub fn replace(&self, rendered: &mut String, command_envs: Vec<(&str, &str)>) -> Result<()> {
+        if let Some(text) = &self.replace {
+            *rendered = self.pattern.replace_all(rendered, text).to_string();
+        } else if let Some(command) = &self.replace_command {
+            if self.pattern.is_match(rendered) {
+                *rendered = command::run(command, Some(rendered.to_string()), command_envs)?;
+            }
+        }
+        Ok(())
+    }
 }
 
 /// Parser for extracting links in commits.
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct LinkParser {
-	/// Regex for finding links in the commit message.
-	#[serde(with = "serde_regex")]
-	pub pattern: Regex,
-	/// The string used to generate the link URL.
-	pub href:    String,
-	/// The string used to generate the link text.
-	pub text:    Option<String>,
+    /// Regex for finding links in the commit message.
+    #[serde(with = "serde_regex")]
+    pub pattern: Regex,
+    /// The string used to generate the link URL.
+    pub href: String,
+    /// The string used to generate the link text.
+    pub text: Option<String>,
 }
 
 impl Config {
-	/// Reads the config file contents from project manifest (e.g. Cargo.toml,
-	/// pyproject.toml)
-	pub fn read_from_manifest() -> Result<Option<String>> {
-		for info in &(*MANIFEST_INFO) {
-			if info.path.exists() {
-				let contents = fs::read_to_string(&info.path)?;
-				if info.regex.is_match(&contents) {
-					return Ok(Some(
-						info.regex.replace_all(&contents, "[").to_string(),
-					));
-				}
-			}
-		}
-		Ok(None)
-	}
-
-	/// Parses the config file from string and returns the values.
-	pub fn parse_from_str(contents: &str) -> Result<Config> {
-		Ok(config::Config::builder()
-			.add_source(config::File::from_str(contents, config::FileFormat::Toml))
-			.add_source(
-				config::Environment::with_prefix("GIT_CLIFF").separator("__"),
-			)
-			.build()?
-			.try_deserialize()?)
-	}
-
-	/// Parses the config file and returns the values.
-	pub fn parse(path: &Path) -> Result<Config> {
-		if MANIFEST_INFO
-			.iter()
-			.any(|v| path.file_name() == v.path.file_name())
-		{
-			if let Some(contents) = Self::read_from_manifest()? {
-				return Self::parse_from_str(&contents);
-			}
-		}
-
-		Ok(config::Config::builder()
-			.add_source(config::File::from(path))
-			.add_source(
-				config::Environment::with_prefix("GIT_CLIFF").separator("__"),
-			)
-			.build()?
-			.try_deserialize()?)
-	}
+    /// Reads the config file contents from project manifest (e.g. Cargo.toml,
+    /// pyproject.toml)
+    pub fn read_from_manifest() -> Result<Option<String>> {
+        for info in &(*MANIFEST_INFO) {
+            if info.path.exists() {
+                let contents = fs::read_to_string(&info.path)?;
+                if info.regex.is_match(&contents) {
+                    return Ok(Some(info.regex.replace_all(&contents, "[").to_string()));
+                }
+            }
+        }
+        Ok(None)
+    }
+
+    /// Parses the config file from string and returns the values.
+    pub fn parse_from_str(contents: &str) -> Result<Config> {
+        Ok(config::Config::builder()
+            .add_source(config::File::from_str(contents, config::FileFormat::Toml))
+            .add_source(config::Environment::with_prefix("GIT_CLIFF").separator("__"))
+            .build()?
+            .try_deserialize()?)
+    }
+
+    /// Parses the config file and returns the values.
+    pub fn parse(path: &Path) -> Result<Config> {
+        if MANIFEST_INFO
+            .iter()
+            .any(|v| path.file_name() == v.path.file_name())
+        {
+            if let Some(contents) = Self::read_from_manifest()? {
+                return Self::parse_from_str(&contents);
+            }
+        }
+
+        Ok(config::Config::builder()
+            .add_source(config::File::from(path))
+            .add_source(config::Environment::with_prefix("GIT_CLIFF").separator("__"))
+            .build()?
+            .try_deserialize()?)
+    }
 }
 
 #[cfg(test)]
 mod test {
-	use super::*;
-	use pretty_assertions::assert_eq;
-	use std::env;
-	#[test]
-	fn parse_config() -> Result<()> {
-		let path = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
-			.parent()
-			.expect("parent directory not found")
-			.to_path_buf()
-			.join("config")
-			.join(crate::DEFAULT_CONFIG);
-
-		const FOOTER_VALUE: &str = "test";
-		const TAG_PATTERN_VALUE: &str = ".*[0-9].*";
-		const IGNORE_TAGS_VALUE: &str = "v[0-9]+.[0-9]+.[0-9]+-rc[0-9]+";
-
-		env::set_var("GIT_CLIFF__CHANGELOG__FOOTER", FOOTER_VALUE);
-		env::set_var("GIT_CLIFF__GIT__TAG_PATTERN", TAG_PATTERN_VALUE);
-		env::set_var("GIT_CLIFF__GIT__IGNORE_TAGS", IGNORE_TAGS_VALUE);
-
-		let config = Config::parse(&path)?;
-
-		assert_eq!(Some(String::from(FOOTER_VALUE)), config.changelog.footer);
-		assert_eq!(
-			Some(String::from(TAG_PATTERN_VALUE)),
-			config
-				.git
-				.tag_pattern
-				.map(|tag_pattern| tag_pattern.to_string())
-		);
-		assert_eq!(
-			Some(String::from(IGNORE_TAGS_VALUE)),
-			config
-				.git
-				.ignore_tags
-				.map(|ignore_tags| ignore_tags.to_string())
-		);
-		Ok(())
-	}
-
-	#[test]
-	fn remote_config() {
-		let remote1 = Remote::new("abc", "xyz1");
-		let remote2 = Remote::new("abc", "xyz2");
-		assert!(!remote1.eq(&remote2));
-		assert_eq!("abc/xyz1", remote1.to_string());
-		assert!(remote1.is_set());
-		assert!(!Remote::new("", "test").is_set());
-		assert!(!Remote::new("test", "").is_set());
-		assert!(!Remote::new("", "").is_set());
-	}
+    use super::*;
+    use pretty_assertions::assert_eq;
+    use std::env;
+    #[test]
+    fn parse_config() -> Result<()> {
+        let path = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
+            .parent()
+            .expect("parent directory not found")
+            .to_path_buf()
+            .join("config")
+            .join(crate::DEFAULT_CONFIG);
+
+        const FOOTER_VALUE: &str = "test";
+        const TAG_PATTERN_VALUE: &str = ".*[0-9].*";
+        const IGNORE_TAGS_VALUE: &str = "v[0-9]+.[0-9]+.[0-9]+-rc[0-9]+";
+
+        env::set_var("GIT_CLIFF__CHANGELOG__FOOTER", FOOTER_VALUE);
+        env::set_var("GIT_CLIFF__GIT__TAG_PATTERN", TAG_PATTERN_VALUE);
+        env::set_var("GIT_CLIFF__GIT__IGNORE_TAGS", IGNORE_TAGS_VALUE);
+
+        let config = Config::parse(&path)?;
+
+        assert_eq!(Some(String::from(FOOTER_VALUE)), config.changelog.footer);
+        assert_eq!(
+            Some(String::from(TAG_PATTERN_VALUE)),
+            config
+                .git
+                .tag_pattern
+                .map(|tag_pattern| tag_pattern.to_string())
+        );
+        assert_eq!(
+            Some(String::from(IGNORE_TAGS_VALUE)),
+            config
+                .git
+                .ignore_tags
+                .map(|ignore_tags| ignore_tags.to_string())
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn remote_config() {
+        let remote1 = Remote::new("abc", "xyz1");
+        let remote2 = Remote::new("abc", "xyz2");
+        assert!(!remote1.eq(&remote2));
+        assert_eq!("abc/xyz1", remote1.to_string());
+        assert!(remote1.is_set());
+        assert!(!Remote::new("", "test").is_set());
+        assert!(!Remote::new("test", "").is_set());
+        assert!(!Remote::new("", "").is_set());
+    }
 }
diff --git a/git-cliff-core/src/contributor.rs b/git-cliff-core/src/contributor.rs
index 957ce4a91a..592697d936 100644
--- a/git-cliff-core/src/contributor.rs
+++ b/git-cliff-core/src/contributor.rs
@@ -1,29 +1,23 @@
-use serde::{
-	Deserialize,
-	Serialize,
-};
-use std::hash::{
-	Hash,
-	Hasher,
-};
+use serde::{Deserialize, Serialize};
+use std::hash::{Hash, Hasher};
 
 /// Representation of a remote contributor.
 #[derive(Debug, Default, Clone, Eq, PartialEq, Deserialize, Serialize)]
 pub struct RemoteContributor {
-	/// Username.
-	pub username:      Option<String>,
-	/// Title of the pull request.
-	pub pr_title:      Option<String>,
-	/// The pull request that the user created.
-	pub pr_number:     Option<i64>,
-	/// Labels of the pull request.
-	pub pr_labels:     Vec<String>,
-	/// Whether if the user contributed for the first time.
-	pub is_first_time: bool,
+    /// Username.
+    pub username: Option<String>,
+    /// Title of the pull request.
+    pub pr_title: Option<String>,
+    /// The pull request that the user created.
+    pub pr_number: Option<i64>,
+    /// Labels of the pull request.
+    pub pr_labels: Vec<String>,
+    /// Whether if the user contributed for the first time.
+    pub is_first_time: bool,
 }
 
 impl Hash for RemoteContributor {
-	fn hash<H: Hasher>(&self, state: &mut H) {
-		self.username.hash(state);
-	}
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.username.hash(state);
+    }
 }
diff --git a/git-cliff-core/src/embed.rs b/git-cliff-core/src/embed.rs
index 79450df2ee..05ab5bafc7 100644
--- a/git-cliff-core/src/embed.rs
+++ b/git-cliff-core/src/embed.rs
@@ -1,8 +1,5 @@
 use crate::config::Config;
-use crate::error::{
-	Error,
-	Result,
-};
+use crate::error::{Error, Result};
 use rust_embed::RustEmbed;
 use std::path::Path;
 use std::str;
@@ -17,22 +14,22 @@ use std::str;
 pub struct EmbeddedConfig;
 
 impl EmbeddedConfig {
-	/// Extracts the embedded content.
-	pub fn get_config() -> Result<String> {
-		match Self::get(crate::DEFAULT_CONFIG) {
-			Some(v) => Ok(str::from_utf8(&v.data)?.to_string()),
-			None => Err(Error::EmbeddedError(String::from(
-				"Embedded config not found",
-			))),
-		}
-	}
+    /// Extracts the embedded content.
+    pub fn get_config() -> Result<String> {
+        match Self::get(crate::DEFAULT_CONFIG) {
+            Some(v) => Ok(str::from_utf8(&v.data)?.to_string()),
+            None => Err(Error::EmbeddedError(String::from(
+                "Embedded config not found",
+            ))),
+        }
+    }
 
-	/// Parses the extracted content into [`Config`].
-	///
-	/// [`Config`]: Config
-	pub fn parse() -> Result<Config> {
-		Config::parse_from_str(&Self::get_config()?)
-	}
+    /// Parses the extracted content into [`Config`].
+    ///
+    /// [`Config`]: Config
+    pub fn parse() -> Result<Config> {
+        Config::parse_from_str(&Self::get_config()?)
+    }
 }
 
 /// Built-in configuration file embedder/extractor.
@@ -43,25 +40,25 @@ impl EmbeddedConfig {
 pub struct BuiltinConfig;
 
 impl BuiltinConfig {
-	/// Extracts the embedded content.
-	pub fn get_config(mut name: String) -> Result<String> {
-		if !Path::new(&name)
-			.extension()
-			.map_or(false, |ext| ext.eq_ignore_ascii_case("toml"))
-		{
-			name = format!("{name}.toml");
-		}
-		let contents = match Self::get(&name) {
-			Some(v) => Ok(str::from_utf8(&v.data)?.to_string()),
-			None => Err(Error::EmbeddedError(format!("config {} not found", name,))),
-		}?;
-		Ok(contents)
-	}
+    /// Extracts the embedded content.
+    pub fn get_config(mut name: String) -> Result<String> {
+        if !Path::new(&name)
+            .extension()
+            .map_or(false, |ext| ext.eq_ignore_ascii_case("toml"))
+        {
+            name = format!("{name}.toml");
+        }
+        let contents = match Self::get(&name) {
+            Some(v) => Ok(str::from_utf8(&v.data)?.to_string()),
+            None => Err(Error::EmbeddedError(format!("config {} not found", name,))),
+        }?;
+        Ok(contents)
+    }
 
-	/// Parses the extracted content into [`Config`] along with the name.
-	///
-	/// [`Config`]: Config
-	pub fn parse(name: String) -> Result<(Config, String)> {
-		Ok((toml::from_str(&Self::get_config(name.to_string())?)?, name))
-	}
+    /// Parses the extracted content into [`Config`] along with the name.
+    ///
+    /// [`Config`]: Config
+    pub fn parse(name: String) -> Result<(Config, String)> {
+        Ok((toml::from_str(&Self::get_config(name.to_string())?)?, name))
+    }
 }
diff --git a/git-cliff-core/src/error.rs b/git-cliff-core/src/error.rs
index 255d99c20d..29d1cb1ef7 100644
--- a/git-cliff-core/src/error.rs
+++ b/git-cliff-core/src/error.rs
@@ -3,104 +3,104 @@ use thiserror::Error as ThisError;
 /// Library related errors that we are exposing to the rest of the workspaces.
 #[derive(Debug, ThisError)]
 pub enum Error {
-	/// Error that may occur while I/O operations.
-	#[error("IO error: `{0}`")]
-	IoError(#[from] std::io::Error),
-	/// Error that may occur when attempting to interpret a sequence of u8 as a
-	/// string.
-	#[error("UTF-8 error: `{0}`")]
-	Utf8Error(#[from] std::str::Utf8Error),
-	/// Error variant that represents errors coming out of libgit2.
-	#[cfg(feature = "repo")]
-	#[error("Git error: `{0}`")]
-	GitError(#[from] git2::Error),
-	/// Error variant that represents other repository related errors.
-	#[cfg(feature = "repo")]
-	#[error("Git repository error: `{0}`")]
-	RepoError(String),
-	/// Error that may occur while parsing the config file.
-	#[error("Cannot parse config: `{0}`")]
-	ConfigError(#[from] config::ConfigError),
-	/// A possible error while initializing the logger.
-	#[error("Logger error: `{0}`")]
-	LoggerError(String),
-	/// When commit's not follow the conventional commit structure we throw this
-	/// error.
-	#[error("Cannot parse the commit: `{0}`")]
-	ParseError(#[from] git_conventional::Error),
-	/// Error that may occur while grouping commits.
-	#[error("Grouping error: `{0}`")]
-	GroupError(String),
-	/// Error that may occur while generating changelog.
-	#[error("Changelog error: `{0}`")]
-	ChangelogError(String),
-	/// Error that may occur while parsing the template.
-	#[error("Template parse error:\n{0}")]
-	TemplateParseError(String),
-	/// Error that may occur while rendering the template.
-	#[error("Template render error:\n{0}")]
-	TemplateRenderError(String),
-	/// Error that may occur while rendering the template.
-	#[error("Template render error:\n{0}\n{1}")]
-	TemplateRenderDetailedError(String, String),
-	/// Error that may occur during more general template operations.
-	#[error("Template error: `{0}`")]
-	TemplateError(#[from] tera::Error),
-	/// Error that may occur while parsing the command line arguments.
-	#[error("Argument error: `{0}`")]
-	ArgumentError(String),
-	/// Error that may occur while extracting the embedded content.
-	#[error("Embedded error: `{0}`")]
-	EmbeddedError(String),
-	/// Errors that may occur when deserializing types from TOML format.
-	#[error("Cannot parse TOML: `{0}`")]
-	DeserializeError(#[from] toml::de::Error),
-	/// Errors that may occur while de/serializing JSON format.
-	#[error("Cannot de/serialize JSON: `{0}`")]
-	JsonError(#[from] serde_json::Error),
-	/// Errors that may occur during parsing or compiling a regular expression.
-	#[error("Cannot parse/compile regex: `{0}`")]
-	RegexError(#[from] regex::Error),
-	/// Error that may occur due to system time related anomalies.
-	#[error("System time error: `{0}`")]
-	SystemTimeError(#[from] std::time::SystemTimeError),
-	/// Error that may occur while parsing integers.
-	#[error("Failed to parse integer: `{0}`")]
-	IntParseError(#[from] std::num::TryFromIntError),
-	/// Error that may occur while processing parsers that define field and
-	/// value matchers.
-	#[error("Field error: `{0}`")]
-	FieldError(String),
-	/// Error that may occur while parsing a `SemVer` version or version
-	/// requirement.
-	#[error("Semver error: `{0}`")]
-	SemverError(#[from] semver::Error),
-	/// The errors that may occur when processing a HTTP request.
-	#[error("HTTP client error: `{0}`")]
-	#[cfg(feature = "remote")]
-	HttpClientError(#[from] reqwest::Error),
-	/// The errors that may occur while constructing the HTTP client with
-	/// middleware.
-	#[error("HTTP client with middleware error: `{0}`")]
-	#[cfg(feature = "remote")]
-	HttpClientMiddlewareError(#[from] reqwest_middleware::Error),
-	/// A possible error when converting a `HeaderValue` from a string or byte
-	/// slice.
-	#[error("HTTP header error: `{0}`")]
-	#[cfg(feature = "remote")]
-	HttpHeaderError(#[from] reqwest::header::InvalidHeaderValue),
-	/// Error that may occur during handling pages.
-	#[error("Pagination error: `{0}`")]
-	PaginationError(String),
-	/// The errors that may occur while parsing URLs.
-	#[error("URL parse error: `{0}`")]
-	UrlParseError(#[from] url::ParseError),
-	/// Error that may occur when a remote is not set.
-	#[error("Repository remote is not set.")]
-	RemoteNotSetError,
-	/// Error that may occur while handling location of directories.
-	#[error("Directory error: `{0}`")]
-	DirsError(String),
+    /// Error that may occur while I/O operations.
+    #[error("IO error: `{0}`")]
+    IoError(#[from] std::io::Error),
+    /// Error that may occur when attempting to interpret a sequence of u8 as a
+    /// string.
+    #[error("UTF-8 error: `{0}`")]
+    Utf8Error(#[from] std::str::Utf8Error),
+    /// Error variant that represents errors coming out of libgit2.
+    #[cfg(feature = "repo")]
+    #[error("Git error: `{0}`")]
+    GitError(#[from] git2::Error),
+    /// Error variant that represents other repository related errors.
+    #[cfg(feature = "repo")]
+    #[error("Git repository error: `{0}`")]
+    RepoError(String),
+    /// Error that may occur while parsing the config file.
+    #[error("Cannot parse config: `{0}`")]
+    ConfigError(#[from] config::ConfigError),
+    /// A possible error while initializing the logger.
+    #[error("Logger error: `{0}`")]
+    LoggerError(String),
+    /// When commit's not follow the conventional commit structure we throw this
+    /// error.
+    #[error("Cannot parse the commit: `{0}`")]
+    ParseError(#[from] git_conventional::Error),
+    /// Error that may occur while grouping commits.
+    #[error("Grouping error: `{0}`")]
+    GroupError(String),
+    /// Error that may occur while generating changelog.
+    #[error("Changelog error: `{0}`")]
+    ChangelogError(String),
+    /// Error that may occur while parsing the template.
+    #[error("Template parse error:\n{0}")]
+    TemplateParseError(String),
+    /// Error that may occur while rendering the template.
+    #[error("Template render error:\n{0}")]
+    TemplateRenderError(String),
+    /// Error that may occur while rendering the template.
+    #[error("Template render error:\n{0}\n{1}")]
+    TemplateRenderDetailedError(String, String),
+    /// Error that may occur during more general template operations.
+    #[error("Template error: `{0}`")]
+    TemplateError(#[from] tera::Error),
+    /// Error that may occur while parsing the command line arguments.
+    #[error("Argument error: `{0}`")]
+    ArgumentError(String),
+    /// Error that may occur while extracting the embedded content.
+    #[error("Embedded error: `{0}`")]
+    EmbeddedError(String),
+    /// Errors that may occur when deserializing types from TOML format.
+    #[error("Cannot parse TOML: `{0}`")]
+    DeserializeError(#[from] toml::de::Error),
+    /// Errors that may occur while de/serializing JSON format.
+    #[error("Cannot de/serialize JSON: `{0}`")]
+    JsonError(#[from] serde_json::Error),
+    /// Errors that may occur during parsing or compiling a regular expression.
+    #[error("Cannot parse/compile regex: `{0}`")]
+    RegexError(#[from] regex::Error),
+    /// Error that may occur due to system time related anomalies.
+    #[error("System time error: `{0}`")]
+    SystemTimeError(#[from] std::time::SystemTimeError),
+    /// Error that may occur while parsing integers.
+    #[error("Failed to parse integer: `{0}`")]
+    IntParseError(#[from] std::num::TryFromIntError),
+    /// Error that may occur while processing parsers that define field and
+    /// value matchers.
+    #[error("Field error: `{0}`")]
+    FieldError(String),
+    /// Error that may occur while parsing a `SemVer` version or version
+    /// requirement.
+    #[error("Semver error: `{0}`")]
+    SemverError(#[from] semver::Error),
+    /// The errors that may occur when processing a HTTP request.
+    #[error("HTTP client error: `{0}`")]
+    #[cfg(feature = "remote")]
+    HttpClientError(#[from] reqwest::Error),
+    /// The errors that may occur while constructing the HTTP client with
+    /// middleware.
+    #[error("HTTP client with middleware error: `{0}`")]
+    #[cfg(feature = "remote")]
+    HttpClientMiddlewareError(#[from] reqwest_middleware::Error),
+    /// A possible error when converting a `HeaderValue` from a string or byte
+    /// slice.
+    #[error("HTTP header error: `{0}`")]
+    #[cfg(feature = "remote")]
+    HttpHeaderError(#[from] reqwest::header::InvalidHeaderValue),
+    /// Error that may occur during handling pages.
+    #[error("Pagination error: `{0}`")]
+    PaginationError(String),
+    /// The errors that may occur while parsing URLs.
+    #[error("URL parse error: `{0}`")]
+    UrlParseError(#[from] url::ParseError),
+    /// Error that may occur when a remote is not set.
+    #[error("Repository remote is not set.")]
+    RemoteNotSetError,
+    /// Error that may occur while handling location of directories.
+    #[error("Directory error: `{0}`")]
+    DirsError(String),
 }
 
 /// Result type of the core library.
@@ -108,26 +108,23 @@ pub type Result<T> = core::result::Result<T, Error>;
 
 #[cfg(test)]
 mod test {
-	use super::*;
-	use git_conventional::{
-		Commit,
-		ErrorKind,
-	};
-	fn mock_function() -> super::Result<Commit<'static>> {
-		Ok(Commit::parse("test")?)
-	}
+    use super::*;
+    use git_conventional::{Commit, ErrorKind};
+    fn mock_function() -> super::Result<Commit<'static>> {
+        Ok(Commit::parse("test")?)
+    }
 
-	#[test]
-	fn throw_parse_error() {
-		let actual_error = mock_function().expect_err("expected error");
-		let expected_error_kind = ErrorKind::MissingType;
-		match actual_error {
-			Error::ParseError(e) => {
-				assert_eq!(expected_error_kind, e.kind());
-			}
-			_ => {
-				unreachable!()
-			}
-		}
-	}
+    #[test]
+    fn throw_parse_error() {
+        let actual_error = mock_function().expect_err("expected error");
+        let expected_error_kind = ErrorKind::MissingType;
+        match actual_error {
+            Error::ParseError(e) => {
+                assert_eq!(expected_error_kind, e.kind());
+            }
+            _ => {
+                unreachable!()
+            }
+        }
+    }
 }
diff --git a/git-cliff-core/src/lib.rs b/git-cliff-core/src/lib.rs
index 1851ca9cd1..55e32ae6ae 100644
--- a/git-cliff-core/src/lib.rs
+++ b/git-cliff-core/src/lib.rs
@@ -8,8 +8,8 @@
 #![cfg_attr(docsrs, feature(doc_auto_cfg))]
 #![warn(missing_docs, clippy::unwrap_used)]
 #![doc(
-	html_logo_url = "https://raw.githubusercontent.com/orhun/git-cliff/main/website/static/img/git-cliff.png",
-	html_favicon_url = "https://raw.githubusercontent.com/orhun/git-cliff/main/website/static/favicon/favicon.ico"
+    html_logo_url = "https://raw.githubusercontent.com/orhun/git-cliff/main/website/static/img/git-cliff.png",
+    html_favicon_url = "https://raw.githubusercontent.com/orhun/git-cliff/main/website/static/favicon/favicon.ico"
 )]
 
 /// Changelog generator.
diff --git a/git-cliff-core/src/release.rs b/git-cliff-core/src/release.rs
index 3e4dd6f7be..3d3eab4eac 100644
--- a/git-cliff-core/src/release.rs
+++ b/git-cliff-core/src/release.rs
@@ -1,63 +1,49 @@
 use crate::error::Result;
-use crate::{
-	commit::Commit,
-	config::Bump,
-	config::BumpType,
-};
+use crate::{commit::Commit, config::Bump, config::BumpType};
 #[cfg(feature = "remote")]
 use crate::{
-	contributor::RemoteContributor,
-	remote::{
-		RemoteCommit,
-		RemotePullRequest,
-		RemoteReleaseMetadata,
-	},
+    contributor::RemoteContributor,
+    remote::{RemoteCommit, RemotePullRequest, RemoteReleaseMetadata},
 };
 
-use next_version::{
-	NextVersion,
-	VersionUpdater,
-};
+use next_version::{NextVersion, VersionUpdater};
 use semver::Version;
-use serde::{
-	Deserialize,
-	Serialize,
-};
+use serde::{Deserialize, Serialize};
 use serde_json::value::Value;
 
 /// Representation of a release.
 #[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
 #[serde(rename_all(serialize = "camelCase"))]
 pub struct Release<'a> {
-	/// Release version, git tag.
-	pub version:    Option<String>,
-	/// git tag's message.
-	pub message:    Option<String>,
-	/// Commits made for the release.
-	pub commits:    Vec<Commit<'a>>,
-	/// Commit ID of the tag.
-	#[serde(rename = "commit_id")]
-	pub commit_id:  Option<String>,
-	/// Timestamp of the release in seconds, from epoch.
-	pub timestamp:  i64,
-	/// Previous release.
-	pub previous:   Option<Box<Release<'a>>>,
-	/// Repository path.
-	pub repository: Option<String>,
-	/// Arbitrary data to be used with the `--from-context` CLI option.
-	pub extra:      Option<Value>,
-	/// Contributors.
-	#[cfg(feature = "github")]
-	pub github:     RemoteReleaseMetadata,
-	/// Contributors.
-	#[cfg(feature = "gitlab")]
-	pub gitlab:     RemoteReleaseMetadata,
-	/// Contributors.
-	#[cfg(feature = "gitea")]
-	pub gitea:      RemoteReleaseMetadata,
-	/// Contributors.
-	#[cfg(feature = "bitbucket")]
-	pub bitbucket:  RemoteReleaseMetadata,
+    /// Release version, git tag.
+    pub version: Option<String>,
+    /// git tag's message.
+    pub message: Option<String>,
+    /// Commits made for the release.
+    pub commits: Vec<Commit<'a>>,
+    /// Commit ID of the tag.
+    #[serde(rename = "commit_id")]
+    pub commit_id: Option<String>,
+    /// Timestamp of the release in seconds, from epoch.
+    pub timestamp: i64,
+    /// Previous release.
+    pub previous: Option<Box<Release<'a>>>,
+    /// Repository path.
+    pub repository: Option<String>,
+    /// Arbitrary data to be used with the `--from-context` CLI option.
+    pub extra: Option<Value>,
+    /// Contributors.
+    #[cfg(feature = "github")]
+    pub github: RemoteReleaseMetadata,
+    /// Contributors.
+    #[cfg(feature = "gitlab")]
+    pub gitlab: RemoteReleaseMetadata,
+    /// Contributors.
+    #[cfg(feature = "gitea")]
+    pub gitea: RemoteReleaseMetadata,
+    /// Contributors.
+    #[cfg(feature = "bitbucket")]
+    pub bitbucket: RemoteReleaseMetadata,
 }
 
 #[cfg(feature = "github")]
@@ -73,1355 +59,1318 @@ crate::update_release_metadata!(gitea, update_gitea_metadata);
 crate::update_release_metadata!(bitbucket, update_bitbucket_metadata);
 
 impl<'a> Release<'a> {
-	/// Calculates the next version based on the commits.
-	///
-	/// It uses the default bump version configuration to calculate the next
-	/// version.
-	pub fn calculate_next_version(&self) -> Result<String> {
-		self.calculate_next_version_with_config(&Bump::default())
-	}
+    /// Calculates the next version based on the commits.
+    ///
+    /// It uses the default bump version configuration to calculate the next
+    /// version.
+    pub fn calculate_next_version(&self) -> Result<String> {
+        self.calculate_next_version_with_config(&Bump::default())
+    }
 
-	/// Calculates the next version based on the commits.
-	///
-	/// It uses the given bump version configuration to calculate the next
-	/// version.
-	pub(super) fn calculate_next_version_with_config(
-		&self,
-		config: &Bump,
-	) -> Result<String> {
-		match self
-			.previous
-			.as_ref()
-			.and_then(|release| release.version.clone())
-		{
-			Some(version) => {
-				let mut semver = Version::parse(&version);
-				let mut prefix = None;
-				if semver.is_err() && version.split('.').count() >= 2 {
-					let mut found_numeric = false;
-					for (i, c) in version.chars().enumerate() {
-						if c.is_numeric() && !found_numeric {
-							found_numeric = true;
-							let version_prefix = version[..i].to_string();
-							let remaining = version[i..].to_string();
-							let version = Version::parse(&remaining);
-							if version.is_ok() {
-								semver = version;
-								prefix = Some(version_prefix);
-								break;
-							}
-						} else if !c.is_numeric() && found_numeric {
-							found_numeric = false;
-						}
-					}
-				}
-				let mut next_version = VersionUpdater::new()
-					.with_features_always_increment_minor(
-						config.features_always_bump_minor.unwrap_or(true),
-					)
-					.with_breaking_always_increment_major(
-						config.breaking_always_bump_major.unwrap_or(true),
-					);
-				if let Some(custom_major_increment_regex) =
-					&config.custom_major_increment_regex
-				{
-					next_version = next_version.with_custom_major_increment_regex(
-						custom_major_increment_regex,
-					)?;
-				}
-				if let Some(custom_minor_increment_regex) =
-					&config.custom_minor_increment_regex
-				{
-					next_version = next_version.with_custom_minor_increment_regex(
-						custom_minor_increment_regex,
-					)?;
-				}
-				let next_version = if let Some(bump_type) = &config.bump_type {
-					match bump_type {
-						BumpType::Major => semver?.increment_major().to_string(),
-						BumpType::Minor => semver?.increment_minor().to_string(),
-						BumpType::Patch => semver?.increment_patch().to_string(),
-					}
-				} else {
-					next_version
-						.increment(
-							&semver?,
-							self.commits
-								.iter()
-								.map(|commit| commit.message.trim_end().to_string())
-								.collect::<Vec<String>>(),
-						)
-						.to_string()
-				};
-				if let Some(prefix) = prefix {
-					Ok(format!("{prefix}{next_version}"))
-				} else {
-					Ok(next_version)
-				}
-			}
-			None => Ok(config.get_initial_tag()),
-		}
-	}
+    /// Calculates the next version based on the commits.
+    ///
+    /// It uses the given bump version configuration to calculate the next
+    /// version.
+    pub(super) fn calculate_next_version_with_config(&self, config: &Bump) -> Result<String> {
+        match self
+            .previous
+            .as_ref()
+            .and_then(|release| release.version.clone())
+        {
+            Some(version) => {
+                let mut semver = Version::parse(&version);
+                let mut prefix = None;
+                if semver.is_err() && version.split('.').count() >= 2 {
+                    let mut found_numeric = false;
+                    for (i, c) in version.chars().enumerate() {
+                        if c.is_numeric() && !found_numeric {
+                            found_numeric = true;
+                            let version_prefix = version[..i].to_string();
+                            let remaining = version[i..].to_string();
+                            let version = Version::parse(&remaining);
+                            if version.is_ok() {
+                                semver = version;
+                                prefix = Some(version_prefix);
+                                break;
+                            }
+                        } else if !c.is_numeric() && found_numeric {
+                            found_numeric = false;
+                        }
+                    }
+                }
+                let mut next_version = VersionUpdater::new()
+                    .with_features_always_increment_minor(
+                        config.features_always_bump_minor.unwrap_or(true),
+                    )
+                    .with_breaking_always_increment_major(
+                        config.breaking_always_bump_major.unwrap_or(true),
+                    );
+                if let Some(custom_major_increment_regex) = &config.custom_major_increment_regex {
+                    next_version = next_version
+                        .with_custom_major_increment_regex(custom_major_increment_regex)?;
+                }
+                if let Some(custom_minor_increment_regex) = &config.custom_minor_increment_regex {
+                    next_version = next_version
+                        .with_custom_minor_increment_regex(custom_minor_increment_regex)?;
+                }
+                let next_version = if let Some(bump_type) = &config.bump_type {
+                    match bump_type {
+                        BumpType::Major => semver?.increment_major().to_string(),
+                        BumpType::Minor => semver?.increment_minor().to_string(),
+                        BumpType::Patch => semver?.increment_patch().to_string(),
+                    }
+                } else {
+                    next_version
+                        .increment(
+                            &semver?,
+                            self.commits
+                                .iter()
+                                .map(|commit| commit.message.trim_end().to_string())
+                                .collect::<Vec<String>>(),
+                        )
+                        .to_string()
+                };
+                if let Some(prefix) = prefix {
+                    Ok(format!("{prefix}{next_version}"))
+                } else {
+                    Ok(next_version)
+                }
+            }
+            None => Ok(config.get_initial_tag()),
+        }
+    }
 }
 
 /// Representation of a list of releases.
 #[derive(Serialize)]
 pub struct Releases<'a> {
-	/// Releases.
-	pub releases: &'a Vec<Release<'a>>,
+    /// Releases.
+    pub releases: &'a Vec<Release<'a>>,
 }
 
 impl<'a> Releases<'a> {
-	/// Returns the list of releases as JSON.
-	pub fn as_json(&self) -> Result<String> {
-		Ok(serde_json::to_string(self.releases)?)
-	}
+    /// Returns the list of releases as JSON.
+    pub fn as_json(&self) -> Result<String> {
+        Ok(serde_json::to_string(self.releases)?)
+    }
 }
 
 #[cfg(test)]
 mod test {
-	use super::*;
-	use pretty_assertions::assert_eq;
-	#[test]
-	fn bump_version() -> Result<()> {
-		fn build_release<'a>(version: &str, commits: &'a [&str]) -> Release<'a> {
-			Release {
-				version: None,
-				message: None,
-				extra: None,
-				commits: commits
-					.iter()
-					.map(|v| Commit::from(v.to_string()))
-					.collect(),
-				commit_id: None,
-				timestamp: 0,
-				previous: Some(Box::new(Release {
-					version: Some(String::from(version)),
-					..Default::default()
-				})),
-				repository: Some(String::from("/root/repo")),
-				#[cfg(feature = "github")]
-				github: crate::remote::RemoteReleaseMetadata {
-					contributors: vec![],
-				},
-				#[cfg(feature = "gitlab")]
-				gitlab: crate::remote::RemoteReleaseMetadata {
-					contributors: vec![],
-				},
-				#[cfg(feature = "gitea")]
-				gitea: crate::remote::RemoteReleaseMetadata {
-					contributors: vec![],
-				},
-				#[cfg(feature = "bitbucket")]
-				bitbucket: crate::remote::RemoteReleaseMetadata {
-					contributors: vec![],
-				},
-			}
-		}
+    use super::*;
+    use pretty_assertions::assert_eq;
+    #[test]
+    fn bump_version() -> Result<()> {
+        fn build_release<'a>(version: &str, commits: &'a [&str]) -> Release<'a> {
+            Release {
+                version: None,
+                message: None,
+                extra: None,
+                commits: commits
+                    .iter()
+                    .map(|v| Commit::from(v.to_string()))
+                    .collect(),
+                commit_id: None,
+                timestamp: 0,
+                previous: Some(Box::new(Release {
+                    version: Some(String::from(version)),
+                    ..Default::default()
+                })),
+                repository: Some(String::from("/root/repo")),
+                #[cfg(feature = "github")]
+                github: crate::remote::RemoteReleaseMetadata {
+                    contributors: vec![],
+                },
+                #[cfg(feature = "gitlab")]
+                gitlab: crate::remote::RemoteReleaseMetadata {
+                    contributors: vec![],
+                },
+                #[cfg(feature = "gitea")]
+                gitea: crate::remote::RemoteReleaseMetadata {
+                    contributors: vec![],
+                },
+                #[cfg(feature = "bitbucket")]
+                bitbucket: crate::remote::RemoteReleaseMetadata {
+                    contributors: vec![],
+                },
+            }
+        }
 
-		let test_shared = [
-			("1.0.0", "1.1.0", vec!["feat: add xyz", "fix: fix xyz"]),
-			("1.0.0", "1.0.1", vec!["fix: add xyz", "fix: aaaaaa"]),
-			("1.0.0", "2.0.0", vec!["feat!: add xyz", "feat: zzz"]),
-			("1.0.0", "2.0.0", vec!["feat!: add xyz\n", "feat: zzz\n"]),
-			("2.0.0", "2.0.1", vec!["fix: something"]),
-			("foo/1.0.0", "foo/1.1.0", vec![
-				"feat: add xyz",
-				"fix: fix xyz",
-			]),
-			("bar/1.0.0", "bar/2.0.0", vec![
-				"fix: add xyz",
-				"fix!: aaaaaa",
-			]),
-			("zzz-123/test/1.0.0", "zzz-123/test/1.0.1", vec![
-				"fix: aaaaaa",
-			]),
-			("v100.0.0", "v101.0.0", vec!["feat!: something"]),
-			("v1.0.0-alpha.1", "v1.0.0-alpha.2", vec!["fix: minor"]),
-			("testing/v1.0.0-beta.1", "testing/v1.0.0-beta.2", vec![
-				"feat: nice",
-			]),
-			("tauri-v1.5.4", "tauri-v1.6.0", vec!["feat: something"]),
-			(
-				"rocket/rocket-v4.0.0-rc.1",
-				"rocket/rocket-v4.0.0-rc.2",
-				vec!["chore!: wow"],
-			),
-			(
-				"aaa#/@#$@9384!#%^#@#@!#!239432413-idk-9999.2200.5932-alpha.419",
-				"aaa#/@#$@9384!#%^#@#@!#!239432413-idk-9999.2200.5932-alpha.420",
-				vec!["feat: damn this is working"],
-			),
-		];
+        let test_shared = [
+            ("1.0.0", "1.1.0", vec!["feat: add xyz", "fix: fix xyz"]),
+            ("1.0.0", "1.0.1", vec!["fix: add xyz", "fix: aaaaaa"]),
+            ("1.0.0", "2.0.0", vec!["feat!: add xyz", "feat: zzz"]),
+            ("1.0.0", "2.0.0", vec!["feat!: add xyz\n", "feat: zzz\n"]),
+            ("2.0.0", "2.0.1", vec!["fix: something"]),
+            (
+                "foo/1.0.0",
+                "foo/1.1.0",
+                vec!["feat: add xyz", "fix: fix xyz"],
+            ),
+            (
+                "bar/1.0.0",
+                "bar/2.0.0",
+                vec!["fix: add xyz", "fix!: aaaaaa"],
+            ),
+            (
+                "zzz-123/test/1.0.0",
+                "zzz-123/test/1.0.1",
+                vec!["fix: aaaaaa"],
+            ),
+            ("v100.0.0", "v101.0.0", vec!["feat!: something"]),
+            ("v1.0.0-alpha.1", "v1.0.0-alpha.2", vec!["fix: minor"]),
+            (
+                "testing/v1.0.0-beta.1",
+                "testing/v1.0.0-beta.2",
+                vec!["feat: nice"],
+            ),
+            ("tauri-v1.5.4", "tauri-v1.6.0", vec!["feat: something"]),
+            (
+                "rocket/rocket-v4.0.0-rc.1",
+                "rocket/rocket-v4.0.0-rc.2",
+                vec!["chore!: wow"],
+            ),
+            (
+                "aaa#/@#$@9384!#%^#@#@!#!239432413-idk-9999.2200.5932-alpha.419",
+                "aaa#/@#$@9384!#%^#@#@!#!239432413-idk-9999.2200.5932-alpha.420",
+                vec!["feat: damn this is working"],
+            ),
+        ];
 
-		for (version, expected_version, commits) in test_shared.iter().chain(
-			[
-				("0.0.1", "0.0.2", vec!["fix: fix xyz"]),
-				("0.0.1", "0.1.0", vec!["feat: add xyz", "fix: fix xyz"]),
-				("0.0.1", "1.0.0", vec!["feat!: add xyz", "feat: zzz"]),
-				("0.1.0", "0.1.1", vec!["fix: fix xyz"]),
-				("0.1.0", "0.2.0", vec!["feat: add xyz", "fix: fix xyz"]),
-				("0.1.0", "1.0.0", vec!["feat!: add xyz", "feat: zzz"]),
-			]
-			.iter(),
-		) {
-			let release = build_release(version, commits);
-			let next_version = release.calculate_next_version()?;
-			assert_eq!(expected_version, &next_version);
-			let next_version =
-				release.calculate_next_version_with_config(&Bump::default())?;
-			assert_eq!(expected_version, &next_version);
-		}
+        for (version, expected_version, commits) in test_shared.iter().chain(
+            [
+                ("0.0.1", "0.0.2", vec!["fix: fix xyz"]),
+                ("0.0.1", "0.1.0", vec!["feat: add xyz", "fix: fix xyz"]),
+                ("0.0.1", "1.0.0", vec!["feat!: add xyz", "feat: zzz"]),
+                ("0.1.0", "0.1.1", vec!["fix: fix xyz"]),
+                ("0.1.0", "0.2.0", vec!["feat: add xyz", "fix: fix xyz"]),
+                ("0.1.0", "1.0.0", vec!["feat!: add xyz", "feat: zzz"]),
+            ]
+            .iter(),
+        ) {
+            let release = build_release(version, commits);
+            let next_version = release.calculate_next_version()?;
+            assert_eq!(expected_version, &next_version);
+            let next_version = release.calculate_next_version_with_config(&Bump::default())?;
+            assert_eq!(expected_version, &next_version);
+        }
 
-		for (version, expected_version, commits) in test_shared.iter().chain(
-			[
-				("0.0.1", "0.0.2", vec!["fix: fix xyz"]),
-				("0.0.1", "0.0.2", vec!["feat: add xyz", "fix: fix xyz"]),
-				("0.0.1", "0.0.2", vec!["feat!: add xyz", "feat: zzz"]),
-				("0.1.0", "0.1.1", vec!["fix: fix xyz"]),
-				("0.1.0", "0.1.1", vec!["feat: add xyz", "fix: fix xyz"]),
-				("0.1.0", "0.2.0", vec!["feat!: add xyz", "feat: zzz"]),
-			]
-			.iter(),
-		) {
-			let release = build_release(version, commits);
-			let next_version =
-				release.calculate_next_version_with_config(&Bump {
-					features_always_bump_minor:   Some(false),
-					breaking_always_bump_major:   Some(false),
-					initial_tag:                  None,
-					custom_major_increment_regex: None,
-					custom_minor_increment_regex: None,
-					bump_type:                    None,
-				})?;
-			assert_eq!(expected_version, &next_version);
-		}
+        for (version, expected_version, commits) in test_shared.iter().chain(
+            [
+                ("0.0.1", "0.0.2", vec!["fix: fix xyz"]),
+                ("0.0.1", "0.0.2", vec!["feat: add xyz", "fix: fix xyz"]),
+                ("0.0.1", "0.0.2", vec!["feat!: add xyz", "feat: zzz"]),
+                ("0.1.0", "0.1.1", vec!["fix: fix xyz"]),
+                ("0.1.0", "0.1.1", vec!["feat: add xyz", "fix: fix xyz"]),
+                ("0.1.0", "0.2.0", vec!["feat!: add xyz", "feat: zzz"]),
+            ]
+            .iter(),
+        ) {
+            let release = build_release(version, commits);
+            let next_version = release.calculate_next_version_with_config(&Bump {
+                features_always_bump_minor: Some(false),
+                breaking_always_bump_major: Some(false),
+                initial_tag: None,
+                custom_major_increment_regex: None,
+                custom_minor_increment_regex: None,
+                bump_type: None,
+            })?;
+            assert_eq!(expected_version, &next_version);
+        }
 
-		for (version, expected_version, commits) in test_shared.iter().chain(
-			[
-				("0.0.1", "0.0.2", vec!["fix: fix xyz"]),
-				("0.0.1", "0.1.0", vec!["feat: add xyz", "fix: fix xyz"]),
-				("0.0.1", "0.1.0", vec!["feat!: add xyz", "feat: zzz"]),
-				("0.1.0", "0.1.1", vec!["fix: fix xyz"]),
-				("0.1.0", "0.2.0", vec!["feat: add xyz", "fix: fix xyz"]),
-				("0.1.0", "0.2.0", vec!["feat!: add xyz", "feat: zzz"]),
-			]
-			.iter(),
-		) {
-			let release = build_release(version, commits);
-			let next_version =
-				release.calculate_next_version_with_config(&Bump {
-					features_always_bump_minor:   Some(true),
-					breaking_always_bump_major:   Some(false),
-					initial_tag:                  None,
-					custom_major_increment_regex: None,
-					custom_minor_increment_regex: None,
-					bump_type:                    None,
-				})?;
-			assert_eq!(expected_version, &next_version);
-		}
+        for (version, expected_version, commits) in test_shared.iter().chain(
+            [
+                ("0.0.1", "0.0.2", vec!["fix: fix xyz"]),
+                ("0.0.1", "0.1.0", vec!["feat: add xyz", "fix: fix xyz"]),
+                ("0.0.1", "0.1.0", vec!["feat!: add xyz", "feat: zzz"]),
+                ("0.1.0", "0.1.1", vec!["fix: fix xyz"]),
+                ("0.1.0", "0.2.0", vec!["feat: add xyz", "fix: fix xyz"]),
+                ("0.1.0", "0.2.0", vec!["feat!: add xyz", "feat: zzz"]),
+            ]
+            .iter(),
+        ) {
+            let release = build_release(version, commits);
+            let next_version = release.calculate_next_version_with_config(&Bump {
+                features_always_bump_minor: Some(true),
+                breaking_always_bump_major: Some(false),
+                initial_tag: None,
+                custom_major_increment_regex: None,
+                custom_minor_increment_regex: None,
+                bump_type: None,
+            })?;
+            assert_eq!(expected_version, &next_version);
+        }
 
-		for (version, expected_version, commits) in test_shared.iter().chain(
-			[
-				("0.0.1", "0.0.2", vec!["fix: fix xyz"]),
-				("0.0.1", "0.0.2", vec!["feat: add xyz", "fix: fix xyz"]),
-				("0.0.1", "1.0.0", vec!["feat!: add xyz", "feat: zzz"]),
-				("0.1.0", "0.1.1", vec!["fix: fix xyz"]),
-				("0.1.0", "0.1.1", vec!["feat: add xyz", "fix: fix xyz"]),
-				("0.1.0", "1.0.0", vec!["feat!: add xyz", "feat: zzz"]),
-			]
-			.iter(),
-		) {
-			let release = build_release(version, commits);
-			let next_version =
-				release.calculate_next_version_with_config(&Bump {
-					features_always_bump_minor:   Some(false),
-					breaking_always_bump_major:   Some(true),
-					initial_tag:                  None,
-					custom_major_increment_regex: None,
-					custom_minor_increment_regex: None,
-					bump_type:                    None,
-				})?;
-			assert_eq!(expected_version, &next_version);
-		}
+        for (version, expected_version, commits) in test_shared.iter().chain(
+            [
+                ("0.0.1", "0.0.2", vec!["fix: fix xyz"]),
+                ("0.0.1", "0.0.2", vec!["feat: add xyz", "fix: fix xyz"]),
+                ("0.0.1", "1.0.0", vec!["feat!: add xyz", "feat: zzz"]),
+                ("0.1.0", "0.1.1", vec!["fix: fix xyz"]),
+                ("0.1.0", "0.1.1", vec!["feat: add xyz", "fix: fix xyz"]),
+                ("0.1.0", "1.0.0", vec!["feat!: add xyz", "feat: zzz"]),
+            ]
+            .iter(),
+        ) {
+            let release = build_release(version, commits);
+            let next_version = release.calculate_next_version_with_config(&Bump {
+                features_always_bump_minor: Some(false),
+                breaking_always_bump_major: Some(true),
+                initial_tag: None,
+                custom_major_increment_regex: None,
+                custom_minor_increment_regex: None,
+                bump_type: None,
+            })?;
+            assert_eq!(expected_version, &next_version);
+        }
 
-		let empty_release = Release {
-			previous: Some(Box::new(Release {
-				version: None,
-				..Default::default()
-			})),
-			..Default::default()
-		};
-		assert_eq!("0.1.0", empty_release.calculate_next_version()?);
-		for (features_always_bump_minor, breaking_always_bump_major) in
-			[(true, true), (true, false), (false, true), (false, false)]
-		{
-			assert_eq!(
-				"0.1.0",
-				empty_release.calculate_next_version_with_config(&Bump {
-					features_always_bump_minor:   Some(features_always_bump_minor),
-					breaking_always_bump_major:   Some(breaking_always_bump_major),
-					initial_tag:                  None,
-					custom_major_increment_regex: None,
-					custom_minor_increment_regex: None,
-					bump_type:                    None,
-				})?
-			);
-		}
-		Ok(())
-	}
+        let empty_release = Release {
+            previous: Some(Box::new(Release {
+                version: None,
+                ..Default::default()
+            })),
+            ..Default::default()
+        };
+        assert_eq!("0.1.0", empty_release.calculate_next_version()?);
+        for (features_always_bump_minor, breaking_always_bump_major) in
+            [(true, true), (true, false), (false, true), (false, false)]
+        {
+            assert_eq!(
+                "0.1.0",
+                empty_release.calculate_next_version_with_config(&Bump {
+                    features_always_bump_minor: Some(features_always_bump_minor),
+                    breaking_always_bump_major: Some(breaking_always_bump_major),
+                    initial_tag: None,
+                    custom_major_increment_regex: None,
+                    custom_minor_increment_regex: None,
+                    bump_type: None,
+                })?
+            );
+        }
+        Ok(())
+    }
 
-	#[cfg(feature = "github")]
-	#[test]
-	fn update_github_metadata() -> Result<()> {
-		use crate::remote::github::{
-			GitHubCommit,
-			GitHubCommitAuthor,
-			GitHubPullRequest,
-			PullRequestLabel,
-		};
+    #[cfg(feature = "github")]
+    #[test]
+    fn update_github_metadata() -> Result<()> {
+        use crate::remote::github::{
+            GitHubCommit, GitHubCommitAuthor, GitHubPullRequest, PullRequestLabel,
+        };
 
-		let mut release = Release {
-			version: None,
-			message: None,
-			extra: None,
-			commits: vec![
-				Commit::from(String::from(
-					"1d244937ee6ceb8e0314a4a201ba93a7a61f2071 add github \
+        let mut release = Release {
+            version: None,
+            message: None,
+            extra: None,
+            commits: vec![
+                Commit::from(String::from(
+                    "1d244937ee6ceb8e0314a4a201ba93a7a61f2071 add github \
 					 integration",
-				)),
-				Commit::from(String::from(
-					"21f6aa587fcb772de13f2fde0e92697c51f84162 fix github \
+                )),
+                Commit::from(String::from(
+                    "21f6aa587fcb772de13f2fde0e92697c51f84162 fix github \
 					 integration",
-				)),
-				Commit::from(String::from(
-					"35d8c6b6329ecbcf131d7df02f93c3bbc5ba5973 update metadata",
-				)),
-				Commit::from(String::from(
-					"4d3ffe4753b923f4d7807c490e650e6624a12074 do some stuff",
-				)),
-				Commit::from(String::from(
-					"5a55e92e5a62dc5bf9872ffb2566959fad98bd05 alright",
-				)),
-				Commit::from(String::from(
-					"6c34967147560ea09658776d4901709139b4ad66 should be fine",
-				)),
-			],
-			commit_id: None,
-			timestamp: 0,
-			previous: Some(Box::new(Release {
-				version: Some(String::from("1.0.0")),
-				..Default::default()
-			})),
-			repository: Some(String::from("/root/repo")),
-			github: RemoteReleaseMetadata {
-				contributors: vec![],
-			},
-			#[cfg(feature = "gitlab")]
-			gitlab: RemoteReleaseMetadata {
-				contributors: vec![],
-			},
-			#[cfg(feature = "gitea")]
-			gitea: RemoteReleaseMetadata {
-				contributors: vec![],
-			},
-			#[cfg(feature = "bitbucket")]
-			bitbucket: RemoteReleaseMetadata {
-				contributors: vec![],
-			},
-		};
-		release.update_github_metadata(
-			vec![
-				GitHubCommit {
-					sha:    String::from("1d244937ee6ceb8e0314a4a201ba93a7a61f2071"),
-					author: Some(GitHubCommitAuthor {
-						login: Some(String::from("orhun")),
-					}),
-				},
-				GitHubCommit {
-					sha:    String::from("21f6aa587fcb772de13f2fde0e92697c51f84162"),
-					author: Some(GitHubCommitAuthor {
-						login: Some(String::from("orhun")),
-					}),
-				},
-				GitHubCommit {
-					sha:    String::from("35d8c6b6329ecbcf131d7df02f93c3bbc5ba5973"),
-					author: Some(GitHubCommitAuthor {
-						login: Some(String::from("nuhro")),
-					}),
-				},
-				GitHubCommit {
-					sha:    String::from("4d3ffe4753b923f4d7807c490e650e6624a12074"),
-					author: Some(GitHubCommitAuthor {
-						login: Some(String::from("awesome_contributor")),
-					}),
-				},
-				GitHubCommit {
-					sha:    String::from("5a55e92e5a62dc5bf9872ffb2566959fad98bd05"),
-					author: Some(GitHubCommitAuthor {
-						login: Some(String::from("orhun")),
-					}),
-				},
-				GitHubCommit {
-					sha:    String::from("6c34967147560ea09658776d4901709139b4ad66"),
-					author: Some(GitHubCommitAuthor {
-						login: Some(String::from("someone")),
-					}),
-				},
-				GitHubCommit {
-					sha:    String::from("0c34967147560e809658776d4901709139b4ad68"),
-					author: Some(GitHubCommitAuthor {
-						login: Some(String::from("idk")),
-					}),
-				},
-				GitHubCommit {
-					sha:    String::from("kk34967147560e809658776d4901709139b4ad68"),
-					author: None,
-				},
-				GitHubCommit {
-					sha:    String::new(),
-					author: None,
-				},
-			]
-			.into_iter()
-			.map(|v| Box::new(v) as Box<dyn RemoteCommit>)
-			.collect(),
-			vec![
-				GitHubPullRequest {
-					title:            Some(String::from("1")),
-					number:           42,
-					merge_commit_sha: Some(String::from(
-						"1d244937ee6ceb8e0314a4a201ba93a7a61f2071",
-					)),
-					labels:           vec![PullRequestLabel {
-						name: String::from("rust"),
-					}],
-				},
-				GitHubPullRequest {
-					title:            Some(String::from("2")),
-					number:           66,
-					merge_commit_sha: Some(String::from(
-						"21f6aa587fcb772de13f2fde0e92697c51f84162",
-					)),
-					labels:           vec![PullRequestLabel {
-						name: String::from("rust"),
-					}],
-				},
-				GitHubPullRequest {
-					title:            Some(String::from("3")),
-					number:           53,
-					merge_commit_sha: Some(String::from(
-						"35d8c6b6329ecbcf131d7df02f93c3bbc5ba5973",
-					)),
-					labels:           vec![PullRequestLabel {
-						name: String::from("deps"),
-					}],
-				},
-				GitHubPullRequest {
-					title:            Some(String::from("4")),
-					number:           1000,
-					merge_commit_sha: Some(String::from(
-						"4d3ffe4753b923f4d7807c490e650e6624a12074",
-					)),
-					labels:           vec![PullRequestLabel {
-						name: String::from("deps"),
-					}],
-				},
-				GitHubPullRequest {
-					title:            Some(String::from("5")),
-					number:           999999,
-					merge_commit_sha: Some(String::from(
-						"5a55e92e5a62dc5bf9872ffb2566959fad98bd05",
-					)),
-					labels:           vec![PullRequestLabel {
-						name: String::from("github"),
-					}],
-				},
-			]
-			.into_iter()
-			.map(|v| Box::new(v) as Box<dyn RemotePullRequest>)
-			.collect(),
-		)?;
-		#[allow(deprecated)]
-		let expected_commits = vec![
-			Commit {
-				id: String::from("1d244937ee6ceb8e0314a4a201ba93a7a61f2071"),
-				message: String::from("add github integration"),
-				github: RemoteContributor {
-					username:      Some(String::from("orhun")),
-					pr_title:      Some(String::from("1")),
-					pr_number:     Some(42),
-					pr_labels:     vec![String::from("rust")],
-					is_first_time: false,
-				},
-				remote: Some(RemoteContributor {
-					username:      Some(String::from("orhun")),
-					pr_title:      Some(String::from("1")),
-					pr_number:     Some(42),
-					pr_labels:     vec![String::from("rust")],
-					is_first_time: false,
-				}),
-				..Default::default()
-			},
-			Commit {
-				id: String::from("21f6aa587fcb772de13f2fde0e92697c51f84162"),
-				message: String::from("fix github integration"),
-				github: RemoteContributor {
-					username:      Some(String::from("orhun")),
-					pr_title:      Some(String::from("2")),
-					pr_number:     Some(66),
-					pr_labels:     vec![String::from("rust")],
-					is_first_time: false,
-				},
-				remote: Some(RemoteContributor {
-					username:      Some(String::from("orhun")),
-					pr_title:      Some(String::from("2")),
-					pr_number:     Some(66),
-					pr_labels:     vec![String::from("rust")],
-					is_first_time: false,
-				}),
-				..Default::default()
-			},
-			Commit {
-				id: String::from("35d8c6b6329ecbcf131d7df02f93c3bbc5ba5973"),
-				message: String::from("update metadata"),
-				github: RemoteContributor {
-					username:      Some(String::from("nuhro")),
-					pr_title:      Some(String::from("3")),
-					pr_number:     Some(53),
-					pr_labels:     vec![String::from("deps")],
-					is_first_time: false,
-				},
-				remote: Some(RemoteContributor {
-					username:      Some(String::from("nuhro")),
-					pr_title:      Some(String::from("3")),
-					pr_number:     Some(53),
-					pr_labels:     vec![String::from("deps")],
-					is_first_time: false,
-				}),
-				..Default::default()
-			},
-			Commit {
-				id: String::from("4d3ffe4753b923f4d7807c490e650e6624a12074"),
-				message: String::from("do some stuff"),
-				github: RemoteContributor {
-					username:      Some(String::from("awesome_contributor")),
-					pr_title:      Some(String::from("4")),
-					pr_number:     Some(1000),
-					pr_labels:     vec![String::from("deps")],
-					is_first_time: false,
-				},
-				remote: Some(RemoteContributor {
-					username:      Some(String::from("awesome_contributor")),
-					pr_title:      Some(String::from("4")),
-					pr_number:     Some(1000),
-					pr_labels:     vec![String::from("deps")],
-					is_first_time: false,
-				}),
-				..Default::default()
-			},
-			Commit {
-				id: String::from("5a55e92e5a62dc5bf9872ffb2566959fad98bd05"),
-				message: String::from("alright"),
-				github: RemoteContributor {
-					username:      Some(String::from("orhun")),
-					pr_title:      Some(String::from("5")),
-					pr_number:     Some(999999),
-					pr_labels:     vec![String::from("github")],
-					is_first_time: false,
-				},
-				remote: Some(RemoteContributor {
-					username:      Some(String::from("orhun")),
-					pr_title:      Some(String::from("5")),
-					pr_number:     Some(999999),
-					pr_labels:     vec![String::from("github")],
-					is_first_time: false,
-				}),
-				..Default::default()
-			},
-			Commit {
-				id: String::from("6c34967147560ea09658776d4901709139b4ad66"),
-				message: String::from("should be fine"),
-				github: RemoteContributor {
-					username:      Some(String::from("someone")),
-					pr_title:      None,
-					pr_number:     None,
-					pr_labels:     vec![],
-					is_first_time: false,
-				},
-				remote: Some(RemoteContributor {
-					username:      Some(String::from("someone")),
-					pr_title:      None,
-					pr_number:     None,
-					pr_labels:     vec![],
-					is_first_time: false,
-				}),
-				..Default::default()
-			},
-		];
-		assert_eq!(expected_commits, release.commits);
+                )),
+                Commit::from(String::from(
+                    "35d8c6b6329ecbcf131d7df02f93c3bbc5ba5973 update metadata",
+                )),
+                Commit::from(String::from(
+                    "4d3ffe4753b923f4d7807c490e650e6624a12074 do some stuff",
+                )),
+                Commit::from(String::from(
+                    "5a55e92e5a62dc5bf9872ffb2566959fad98bd05 alright",
+                )),
+                Commit::from(String::from(
+                    "6c34967147560ea09658776d4901709139b4ad66 should be fine",
+                )),
+            ],
+            commit_id: None,
+            timestamp: 0,
+            previous: Some(Box::new(Release {
+                version: Some(String::from("1.0.0")),
+                ..Default::default()
+            })),
+            repository: Some(String::from("/root/repo")),
+            github: RemoteReleaseMetadata {
+                contributors: vec![],
+            },
+            #[cfg(feature = "gitlab")]
+            gitlab: RemoteReleaseMetadata {
+                contributors: vec![],
+            },
+            #[cfg(feature = "gitea")]
+            gitea: RemoteReleaseMetadata {
+                contributors: vec![],
+            },
+            #[cfg(feature = "bitbucket")]
+            bitbucket: RemoteReleaseMetadata {
+                contributors: vec![],
+            },
+        };
+        release.update_github_metadata(
+            vec![
+                GitHubCommit {
+                    sha: String::from("1d244937ee6ceb8e0314a4a201ba93a7a61f2071"),
+                    author: Some(GitHubCommitAuthor {
+                        login: Some(String::from("orhun")),
+                    }),
+                },
+                GitHubCommit {
+                    sha: String::from("21f6aa587fcb772de13f2fde0e92697c51f84162"),
+                    author: Some(GitHubCommitAuthor {
+                        login: Some(String::from("orhun")),
+                    }),
+                },
+                GitHubCommit {
+                    sha: String::from("35d8c6b6329ecbcf131d7df02f93c3bbc5ba5973"),
+                    author: Some(GitHubCommitAuthor {
+                        login: Some(String::from("nuhro")),
+                    }),
+                },
+                GitHubCommit {
+                    sha: String::from("4d3ffe4753b923f4d7807c490e650e6624a12074"),
+                    author: Some(GitHubCommitAuthor {
+                        login: Some(String::from("awesome_contributor")),
+                    }),
+                },
+                GitHubCommit {
+                    sha: String::from("5a55e92e5a62dc5bf9872ffb2566959fad98bd05"),
+                    author: Some(GitHubCommitAuthor {
+                        login: Some(String::from("orhun")),
+                    }),
+                },
+                GitHubCommit {
+                    sha: String::from("6c34967147560ea09658776d4901709139b4ad66"),
+                    author: Some(GitHubCommitAuthor {
+                        login: Some(String::from("someone")),
+                    }),
+                },
+                GitHubCommit {
+                    sha: String::from("0c34967147560e809658776d4901709139b4ad68"),
+                    author: Some(GitHubCommitAuthor {
+                        login: Some(String::from("idk")),
+                    }),
+                },
+                GitHubCommit {
+                    sha: String::from("kk34967147560e809658776d4901709139b4ad68"),
+                    author: None,
+                },
+                GitHubCommit {
+                    sha: String::new(),
+                    author: None,
+                },
+            ]
+            .into_iter()
+            .map(|v| Box::new(v) as Box<dyn RemoteCommit>)
+            .collect(),
+            vec![
+                GitHubPullRequest {
+                    title: Some(String::from("1")),
+                    number: 42,
+                    merge_commit_sha: Some(String::from(
+                        "1d244937ee6ceb8e0314a4a201ba93a7a61f2071",
+                    )),
+                    labels: vec![PullRequestLabel {
+                        name: String::from("rust"),
+                    }],
+                },
+                GitHubPullRequest {
+                    title: Some(String::from("2")),
+                    number: 66,
+                    merge_commit_sha: Some(String::from(
+                        "21f6aa587fcb772de13f2fde0e92697c51f84162",
+                    )),
+                    labels: vec![PullRequestLabel {
+                        name: String::from("rust"),
+                    }],
+                },
+                GitHubPullRequest {
+                    title: Some(String::from("3")),
+                    number: 53,
+                    merge_commit_sha: Some(String::from(
+                        "35d8c6b6329ecbcf131d7df02f93c3bbc5ba5973",
+                    )),
+                    labels: vec![PullRequestLabel {
+                        name: String::from("deps"),
+                    }],
+                },
+                GitHubPullRequest {
+                    title: Some(String::from("4")),
+                    number: 1000,
+                    merge_commit_sha: Some(String::from(
+                        "4d3ffe4753b923f4d7807c490e650e6624a12074",
+                    )),
+                    labels: vec![PullRequestLabel {
+                        name: String::from("deps"),
+                    }],
+                },
+                GitHubPullRequest {
+                    title: Some(String::from("5")),
+                    number: 999999,
+                    merge_commit_sha: Some(String::from(
+                        "5a55e92e5a62dc5bf9872ffb2566959fad98bd05",
+                    )),
+                    labels: vec![PullRequestLabel {
+                        name: String::from("github"),
+                    }],
+                },
+            ]
+            .into_iter()
+            .map(|v| Box::new(v) as Box<dyn RemotePullRequest>)
+            .collect(),
+        )?;
+        #[allow(deprecated)]
+        let expected_commits = vec![
+            Commit {
+                id: String::from("1d244937ee6ceb8e0314a4a201ba93a7a61f2071"),
+                message: String::from("add github integration"),
+                github: RemoteContributor {
+                    username: Some(String::from("orhun")),
+                    pr_title: Some(String::from("1")),
+                    pr_number: Some(42),
+                    pr_labels: vec![String::from("rust")],
+                    is_first_time: false,
+                },
+                remote: Some(RemoteContributor {
+                    username: Some(String::from("orhun")),
+                    pr_title: Some(String::from("1")),
+                    pr_number: Some(42),
+                    pr_labels: vec![String::from("rust")],
+                    is_first_time: false,
+                }),
+                ..Default::default()
+            },
+            Commit {
+                id: String::from("21f6aa587fcb772de13f2fde0e92697c51f84162"),
+                message: String::from("fix github integration"),
+                github: RemoteContributor {
+                    username: Some(String::from("orhun")),
+                    pr_title: Some(String::from("2")),
+                    pr_number: Some(66),
+                    pr_labels: vec![String::from("rust")],
+                    is_first_time: false,
+                },
+                remote: Some(RemoteContributor {
+                    username: Some(String::from("orhun")),
+                    pr_title: Some(String::from("2")),
+                    pr_number: Some(66),
+                    pr_labels: vec![String::from("rust")],
+                    is_first_time: false,
+                }),
+                ..Default::default()
+            },
+            Commit {
+                id: String::from("35d8c6b6329ecbcf131d7df02f93c3bbc5ba5973"),
+                message: String::from("update metadata"),
+                github: RemoteContributor {
+                    username: Some(String::from("nuhro")),
+                    pr_title: Some(String::from("3")),
+                    pr_number: Some(53),
+                    pr_labels: vec![String::from("deps")],
+                    is_first_time: false,
+                },
+                remote: Some(RemoteContributor {
+                    username: Some(String::from("nuhro")),
+                    pr_title: Some(String::from("3")),
+                    pr_number: Some(53),
+                    pr_labels: vec![String::from("deps")],
+                    is_first_time: false,
+                }),
+                ..Default::default()
+            },
+            Commit {
+                id: String::from("4d3ffe4753b923f4d7807c490e650e6624a12074"),
+                message: String::from("do some stuff"),
+                github: RemoteContributor {
+                    username: Some(String::from("awesome_contributor")),
+                    pr_title: Some(String::from("4")),
+                    pr_number: Some(1000),
+                    pr_labels: vec![String::from("deps")],
+                    is_first_time: false,
+                },
+                remote: Some(RemoteContributor {
+                    username: Some(String::from("awesome_contributor")),
+                    pr_title: Some(String::from("4")),
+                    pr_number: Some(1000),
+                    pr_labels: vec![String::from("deps")],
+                    is_first_time: false,
+                }),
+                ..Default::default()
+            },
+            Commit {
+                id: String::from("5a55e92e5a62dc5bf9872ffb2566959fad98bd05"),
+                message: String::from("alright"),
+                github: RemoteContributor {
+                    username: Some(String::from("orhun")),
+                    pr_title: Some(String::from("5")),
+                    pr_number: Some(999999),
+                    pr_labels: vec![String::from("github")],
+                    is_first_time: false,
+                },
+                remote: Some(RemoteContributor {
+                    username: Some(String::from("orhun")),
+                    pr_title: Some(String::from("5")),
+                    pr_number: Some(999999),
+                    pr_labels: vec![String::from("github")],
+                    is_first_time: false,
+                }),
+                ..Default::default()
+            },
+            Commit {
+                id: String::from("6c34967147560ea09658776d4901709139b4ad66"),
+                message: String::from("should be fine"),
+                github: RemoteContributor {
+                    username: Some(String::from("someone")),
+                    pr_title: None,
+                    pr_number: None,
+                    pr_labels: vec![],
+                    is_first_time: false,
+                },
+                remote: Some(RemoteContributor {
+                    username: Some(String::from("someone")),
+                    pr_title: None,
+                    pr_number: None,
+                    pr_labels: vec![],
+                    is_first_time: false,
+                }),
+                ..Default::default()
+            },
+        ];
+        assert_eq!(expected_commits, release.commits);
 
-		release
-			.github
-			.contributors
-			.sort_by(|a, b| a.pr_number.cmp(&b.pr_number));
+        release
+            .github
+            .contributors
+            .sort_by(|a, b| a.pr_number.cmp(&b.pr_number));
 
-		let expected_metadata = RemoteReleaseMetadata {
-			contributors: vec![
-				RemoteContributor {
-					username:      Some(String::from("someone")),
-					pr_title:      None,
-					pr_number:     None,
-					pr_labels:     vec![],
-					is_first_time: true,
-				},
-				RemoteContributor {
-					username:      Some(String::from("orhun")),
-					pr_title:      Some(String::from("1")),
-					pr_number:     Some(42),
-					pr_labels:     vec![String::from("rust")],
-					is_first_time: true,
-				},
-				RemoteContributor {
-					username:      Some(String::from("nuhro")),
-					pr_title:      Some(String::from("3")),
-					pr_number:     Some(53),
-					pr_labels:     vec![String::from("deps")],
-					is_first_time: true,
-				},
-				RemoteContributor {
-					username:      Some(String::from("awesome_contributor")),
-					pr_title:      Some(String::from("4")),
-					pr_number:     Some(1000),
-					pr_labels:     vec![String::from("deps")],
-					is_first_time: true,
-				},
-			],
-		};
-		assert_eq!(expected_metadata, release.github);
+        let expected_metadata = RemoteReleaseMetadata {
+            contributors: vec![
+                RemoteContributor {
+                    username: Some(String::from("someone")),
+                    pr_title: None,
+                    pr_number: None,
+                    pr_labels: vec![],
+                    is_first_time: true,
+                },
+                RemoteContributor {
+                    username: Some(String::from("orhun")),
+                    pr_title: Some(String::from("1")),
+                    pr_number: Some(42),
+                    pr_labels: vec![String::from("rust")],
+                    is_first_time: true,
+                },
+                RemoteContributor {
+                    username: Some(String::from("nuhro")),
+                    pr_title: Some(String::from("3")),
+                    pr_number: Some(53),
+                    pr_labels: vec![String::from("deps")],
+                    is_first_time: true,
+                },
+                RemoteContributor {
+                    username: Some(String::from("awesome_contributor")),
+                    pr_title: Some(String::from("4")),
+                    pr_number: Some(1000),
+                    pr_labels: vec![String::from("deps")],
+                    is_first_time: true,
+                },
+            ],
+        };
+        assert_eq!(expected_metadata, release.github);
 
-		Ok(())
-	}
+        Ok(())
+    }
 
-	#[cfg(feature = "gitlab")]
-	#[test]
-	fn update_gitlab_metadata() -> Result<()> {
-		use crate::remote::gitlab::{
-			GitLabCommit,
-			GitLabMergeRequest,
-			GitLabUser,
-		};
+    #[cfg(feature = "gitlab")]
+    #[test]
+    fn update_gitlab_metadata() -> Result<()> {
+        use crate::remote::gitlab::{GitLabCommit, GitLabMergeRequest, GitLabUser};
 
-		let mut release = Release {
-			version: None,
-			message: None,
-			extra: None,
-			commits: vec![
-				Commit::from(String::from(
-					"1d244937ee6ceb8e0314a4a201ba93a7a61f2071 add github \
+        let mut release = Release {
+            version: None,
+            message: None,
+            extra: None,
+            commits: vec![
+                Commit::from(String::from(
+                    "1d244937ee6ceb8e0314a4a201ba93a7a61f2071 add github \
 					 integration",
-				)),
-				Commit::from(String::from(
-					"21f6aa587fcb772de13f2fde0e92697c51f84162 fix github \
+                )),
+                Commit::from(String::from(
+                    "21f6aa587fcb772de13f2fde0e92697c51f84162 fix github \
 					 integration",
-				)),
-				Commit::from(String::from(
-					"35d8c6b6329ecbcf131d7df02f93c3bbc5ba5973 update metadata",
-				)),
-				Commit::from(String::from(
-					"4d3ffe4753b923f4d7807c490e650e6624a12074 do some stuff",
-				)),
-				Commit::from(String::from(
-					"5a55e92e5a62dc5bf9872ffb2566959fad98bd05 alright",
-				)),
-				Commit::from(String::from(
-					"6c34967147560ea09658776d4901709139b4ad66 should be fine",
-				)),
-			],
-			commit_id: None,
-			timestamp: 0,
-			previous: Some(Box::new(Release {
-				version: Some(String::from("1.0.0")),
-				..Default::default()
-			})),
-			repository: Some(String::from("/root/repo")),
-			#[cfg(feature = "github")]
-			github: RemoteReleaseMetadata {
-				contributors: vec![],
-			},
-			#[cfg(feature = "gitlab")]
-			gitlab: RemoteReleaseMetadata {
-				contributors: vec![],
-			},
-			#[cfg(feature = "gitea")]
-			gitea: RemoteReleaseMetadata {
-				contributors: vec![],
-			},
-			#[cfg(feature = "bitbucket")]
-			bitbucket: RemoteReleaseMetadata {
-				contributors: vec![],
-			},
-		};
-		release.update_gitlab_metadata(
-			vec![
-				GitLabCommit {
-					id:              String::from(
-						"1d244937ee6ceb8e0314a4a201ba93a7a61f2071",
-					),
-					author_name:     String::from("orhun"),
-					short_id:        String::from(""),
-					title:           String::from(""),
-					author_email:    String::from(""),
-					authored_date:   String::from(""),
-					committer_name:  String::from(""),
-					committer_email: String::from(""),
-					committed_date:  String::from(""),
-					created_at:      String::from(""),
-					message:         String::from(""),
-					parent_ids:      vec![],
-					web_url:         String::from(""),
-				},
-				GitLabCommit {
-					id:              String::from(
-						"21f6aa587fcb772de13f2fde0e92697c51f84162",
-					),
-					author_name:     String::from("orhun"),
-					short_id:        String::from(""),
-					title:           String::from(""),
-					author_email:    String::from(""),
-					authored_date:   String::from(""),
-					committer_name:  String::from(""),
-					committer_email: String::from(""),
-					committed_date:  String::from(""),
-					created_at:      String::from(""),
-					message:         String::from(""),
-					parent_ids:      vec![],
-					web_url:         String::from(""),
-				},
-				GitLabCommit {
-					id:              String::from(
-						"35d8c6b6329ecbcf131d7df02f93c3bbc5ba5973",
-					),
-					author_name:     String::from("nuhro"),
-					short_id:        String::from(""),
-					title:           String::from(""),
-					author_email:    String::from(""),
-					authored_date:   String::from(""),
-					committer_name:  String::from(""),
-					committer_email: String::from(""),
-					committed_date:  String::from(""),
-					created_at:      String::from(""),
-					message:         String::from(""),
-					parent_ids:      vec![],
-					web_url:         String::from(""),
-				},
-				GitLabCommit {
-					id:              String::from(
-						"4d3ffe4753b923f4d7807c490e650e6624a12074",
-					),
-					author_name:     String::from("awesome_contributor"),
-					short_id:        String::from(""),
-					title:           String::from(""),
-					author_email:    String::from(""),
-					authored_date:   String::from(""),
-					committer_name:  String::from(""),
-					committer_email: String::from(""),
-					committed_date:  String::from(""),
-					created_at:      String::from(""),
-					message:         String::from(""),
-					parent_ids:      vec![],
-					web_url:         String::from(""),
-				},
-				GitLabCommit {
-					id:              String::from(
-						"5a55e92e5a62dc5bf9872ffb2566959fad98bd05",
-					),
-					author_name:     String::from("orhun"),
-					short_id:        String::from(""),
-					title:           String::from(""),
-					author_email:    String::from(""),
-					authored_date:   String::from(""),
-					committer_name:  String::from(""),
-					committer_email: String::from(""),
-					committed_date:  String::from(""),
-					created_at:      String::from(""),
-					message:         String::from(""),
-					parent_ids:      vec![],
-					web_url:         String::from(""),
-				},
-				GitLabCommit {
-					id:              String::from(
-						"6c34967147560ea09658776d4901709139b4ad66",
-					),
-					author_name:     String::from("someone"),
-					short_id:        String::from(""),
-					title:           String::from(""),
-					author_email:    String::from(""),
-					authored_date:   String::from(""),
-					committer_name:  String::from(""),
-					committer_email: String::from(""),
-					committed_date:  String::from(""),
-					created_at:      String::from(""),
-					message:         String::from(""),
-					parent_ids:      vec![],
-					web_url:         String::from(""),
-				},
-				GitLabCommit {
-					id:              String::from(
-						"0c34967147560e809658776d4901709139b4ad68",
-					),
-					author_name:     String::from("idk"),
-					short_id:        String::from(""),
-					title:           String::from(""),
-					author_email:    String::from(""),
-					authored_date:   String::from(""),
-					committer_name:  String::from(""),
-					committer_email: String::from(""),
-					committed_date:  String::from(""),
-					created_at:      String::from(""),
-					message:         String::from(""),
-					parent_ids:      vec![],
-					web_url:         String::from(""),
-				},
-				GitLabCommit {
-					id:              String::from(
-						"kk34967147560e809658776d4901709139b4ad68",
-					),
-					author_name:     String::from("orhun"),
-					short_id:        String::from(""),
-					title:           String::from(""),
-					author_email:    String::from(""),
-					authored_date:   String::from(""),
-					committer_name:  String::from(""),
-					committer_email: String::from(""),
-					committed_date:  String::from(""),
-					created_at:      String::from(""),
-					message:         String::from(""),
-					parent_ids:      vec![],
-					web_url:         String::from(""),
-				},
-			]
-			.into_iter()
-			.map(|v| Box::new(v) as Box<dyn RemoteCommit>)
-			.collect(),
-			vec![Box::new(GitLabMergeRequest {
-				title:             String::from("1"),
-				merge_commit_sha:  Some(String::from(
-					"1d244937ee6ceb8e0314a4a201ba93a7a61f2071",
-				)),
-				id:                1,
-				iid:               1,
-				project_id:        1,
-				description:       String::from(""),
-				state:             String::from(""),
-				created_at:        String::from(""),
-				author:            GitLabUser {
-					id:         1,
-					name:       String::from("42"),
-					username:   String::from("42"),
-					state:      String::from("42"),
-					avatar_url: None,
-					web_url:    String::from("42"),
-				},
-				sha:               String::from(
-					"1d244937ee6ceb8e0314a4a201ba93a7a61f2071",
-				),
-				web_url:           String::from(""),
-				squash_commit_sha: None,
-				labels:            vec![String::from("rust")],
-			})],
-		)?;
-		#[allow(deprecated)]
-		let expected_commits = vec![
-			Commit {
-				id: String::from("1d244937ee6ceb8e0314a4a201ba93a7a61f2071"),
-				message: String::from("add github integration"),
-				gitlab: RemoteContributor {
-					username:      Some(String::from("orhun")),
-					pr_title:      Some(String::from("1")),
-					pr_number:     Some(1),
-					pr_labels:     vec![String::from("rust")],
-					is_first_time: false,
-				},
-				remote: Some(RemoteContributor {
-					username:      Some(String::from("orhun")),
-					pr_title:      Some(String::from("1")),
-					pr_number:     Some(1),
-					pr_labels:     vec![String::from("rust")],
-					is_first_time: false,
-				}),
-				..Default::default()
-			},
-			Commit {
-				id: String::from("21f6aa587fcb772de13f2fde0e92697c51f84162"),
-				message: String::from("fix github integration"),
-				gitlab: RemoteContributor {
-					username:      Some(String::from("orhun")),
-					pr_title:      None,
-					pr_number:     None,
-					pr_labels:     vec![],
-					is_first_time: false,
-				},
-				remote: Some(RemoteContributor {
-					username:      Some(String::from("orhun")),
-					pr_title:      None,
-					pr_number:     None,
-					pr_labels:     vec![],
-					is_first_time: false,
-				}),
-				..Default::default()
-			},
-			Commit {
-				id: String::from("35d8c6b6329ecbcf131d7df02f93c3bbc5ba5973"),
-				message: String::from("update metadata"),
-				gitlab: RemoteContributor {
-					username:      Some(String::from("nuhro")),
-					pr_title:      None,
-					pr_number:     None,
-					pr_labels:     vec![],
-					is_first_time: false,
-				},
-				remote: Some(RemoteContributor {
-					username:      Some(String::from("nuhro")),
-					pr_title:      None,
-					pr_number:     None,
-					pr_labels:     vec![],
-					is_first_time: false,
-				}),
-				..Default::default()
-			},
-			Commit {
-				id: String::from("4d3ffe4753b923f4d7807c490e650e6624a12074"),
-				message: String::from("do some stuff"),
-				gitlab: RemoteContributor {
-					username:      Some(String::from("awesome_contributor")),
-					pr_title:      None,
-					pr_number:     None,
-					pr_labels:     vec![],
-					is_first_time: false,
-				},
-				remote: Some(RemoteContributor {
-					username:      Some(String::from("awesome_contributor")),
-					pr_title:      None,
-					pr_number:     None,
-					pr_labels:     vec![],
-					is_first_time: false,
-				}),
-				..Default::default()
-			},
-			Commit {
-				id: String::from("5a55e92e5a62dc5bf9872ffb2566959fad98bd05"),
-				message: String::from("alright"),
-				gitlab: RemoteContributor {
-					username:      Some(String::from("orhun")),
-					pr_title:      None,
-					pr_number:     None,
-					pr_labels:     vec![],
-					is_first_time: false,
-				},
-				remote: Some(RemoteContributor {
-					username:      Some(String::from("orhun")),
-					pr_title:      None,
-					pr_number:     None,
-					pr_labels:     vec![],
-					is_first_time: false,
-				}),
-				..Default::default()
-			},
-			Commit {
-				id: String::from("6c34967147560ea09658776d4901709139b4ad66"),
-				message: String::from("should be fine"),
-				gitlab: RemoteContributor {
-					username:      Some(String::from("someone")),
-					pr_title:      None,
-					pr_number:     None,
-					pr_labels:     vec![],
-					is_first_time: false,
-				},
-				remote: Some(RemoteContributor {
-					username:      Some(String::from("someone")),
-					pr_title:      None,
-					pr_number:     None,
-					pr_labels:     vec![],
-					is_first_time: false,
-				}),
-				..Default::default()
-			},
-		];
-		assert_eq!(expected_commits, release.commits);
+                )),
+                Commit::from(String::from(
+                    "35d8c6b6329ecbcf131d7df02f93c3bbc5ba5973 update metadata",
+                )),
+                Commit::from(String::from(
+                    "4d3ffe4753b923f4d7807c490e650e6624a12074 do some stuff",
+                )),
+                Commit::from(String::from(
+                    "5a55e92e5a62dc5bf9872ffb2566959fad98bd05 alright",
+                )),
+                Commit::from(String::from(
+                    "6c34967147560ea09658776d4901709139b4ad66 should be fine",
+                )),
+            ],
+            commit_id: None,
+            timestamp: 0,
+            previous: Some(Box::new(Release {
+                version: Some(String::from("1.0.0")),
+                ..Default::default()
+            })),
+            repository: Some(String::from("/root/repo")),
+            #[cfg(feature = "github")]
+            github: RemoteReleaseMetadata {
+                contributors: vec![],
+            },
+            #[cfg(feature = "gitlab")]
+            gitlab: RemoteReleaseMetadata {
+                contributors: vec![],
+            },
+            #[cfg(feature = "gitea")]
+            gitea: RemoteReleaseMetadata {
+                contributors: vec![],
+            },
+            #[cfg(feature = "bitbucket")]
+            bitbucket: RemoteReleaseMetadata {
+                contributors: vec![],
+            },
+        };
+        release.update_gitlab_metadata(
+            vec![
+                GitLabCommit {
+                    id: String::from("1d244937ee6ceb8e0314a4a201ba93a7a61f2071"),
+                    author_name: String::from("orhun"),
+                    short_id: String::from(""),
+                    title: String::from(""),
+                    author_email: String::from(""),
+                    authored_date: String::from(""),
+                    committer_name: String::from(""),
+                    committer_email: String::from(""),
+                    committed_date: String::from(""),
+                    created_at: String::from(""),
+                    message: String::from(""),
+                    parent_ids: vec![],
+                    web_url: String::from(""),
+                },
+                GitLabCommit {
+                    id: String::from("21f6aa587fcb772de13f2fde0e92697c51f84162"),
+                    author_name: String::from("orhun"),
+                    short_id: String::from(""),
+                    title: String::from(""),
+                    author_email: String::from(""),
+                    authored_date: String::from(""),
+                    committer_name: String::from(""),
+                    committer_email: String::from(""),
+                    committed_date: String::from(""),
+                    created_at: String::from(""),
+                    message: String::from(""),
+                    parent_ids: vec![],
+                    web_url: String::from(""),
+                },
+                GitLabCommit {
+                    id: String::from("35d8c6b6329ecbcf131d7df02f93c3bbc5ba5973"),
+                    author_name: String::from("nuhro"),
+                    short_id: String::from(""),
+                    title: String::from(""),
+                    author_email: String::from(""),
+                    authored_date: String::from(""),
+                    committer_name: String::from(""),
+                    committer_email: String::from(""),
+                    committed_date: String::from(""),
+                    created_at: String::from(""),
+                    message: String::from(""),
+                    parent_ids: vec![],
+                    web_url: String::from(""),
+                },
+                GitLabCommit {
+                    id: String::from("4d3ffe4753b923f4d7807c490e650e6624a12074"),
+                    author_name: String::from("awesome_contributor"),
+                    short_id: String::from(""),
+                    title: String::from(""),
+                    author_email: String::from(""),
+                    authored_date: String::from(""),
+                    committer_name: String::from(""),
+                    committer_email: String::from(""),
+                    committed_date: String::from(""),
+                    created_at: String::from(""),
+                    message: String::from(""),
+                    parent_ids: vec![],
+                    web_url: String::from(""),
+                },
+                GitLabCommit {
+                    id: String::from("5a55e92e5a62dc5bf9872ffb2566959fad98bd05"),
+                    author_name: String::from("orhun"),
+                    short_id: String::from(""),
+                    title: String::from(""),
+                    author_email: String::from(""),
+                    authored_date: String::from(""),
+                    committer_name: String::from(""),
+                    committer_email: String::from(""),
+                    committed_date: String::from(""),
+                    created_at: String::from(""),
+                    message: String::from(""),
+                    parent_ids: vec![],
+                    web_url: String::from(""),
+                },
+                GitLabCommit {
+                    id: String::from("6c34967147560ea09658776d4901709139b4ad66"),
+                    author_name: String::from("someone"),
+                    short_id: String::from(""),
+                    title: String::from(""),
+                    author_email: String::from(""),
+                    authored_date: String::from(""),
+                    committer_name: String::from(""),
+                    committer_email: String::from(""),
+                    committed_date: String::from(""),
+                    created_at: String::from(""),
+                    message: String::from(""),
+                    parent_ids: vec![],
+                    web_url: String::from(""),
+                },
+                GitLabCommit {
+                    id: String::from("0c34967147560e809658776d4901709139b4ad68"),
+                    author_name: String::from("idk"),
+                    short_id: String::from(""),
+                    title: String::from(""),
+                    author_email: String::from(""),
+                    authored_date: String::from(""),
+                    committer_name: String::from(""),
+                    committer_email: String::from(""),
+                    committed_date: String::from(""),
+                    created_at: String::from(""),
+                    message: String::from(""),
+                    parent_ids: vec![],
+                    web_url: String::from(""),
+                },
+                GitLabCommit {
+                    id: String::from("kk34967147560e809658776d4901709139b4ad68"),
+                    author_name: String::from("orhun"),
+                    short_id: String::from(""),
+                    title: String::from(""),
+                    author_email: String::from(""),
+                    authored_date: String::from(""),
+                    committer_name: String::from(""),
+                    committer_email: String::from(""),
+                    committed_date: String::from(""),
+                    created_at: String::from(""),
+                    message: String::from(""),
+                    parent_ids: vec![],
+                    web_url: String::from(""),
+                },
+            ]
+            .into_iter()
+            .map(|v| Box::new(v) as Box<dyn RemoteCommit>)
+            .collect(),
+            vec![Box::new(GitLabMergeRequest {
+                title: String::from("1"),
+                merge_commit_sha: Some(String::from("1d244937ee6ceb8e0314a4a201ba93a7a61f2071")),
+                id: 1,
+                iid: 1,
+                project_id: 1,
+                description: String::from(""),
+                state: String::from(""),
+                created_at: String::from(""),
+                author: GitLabUser {
+                    id: 1,
+                    name: String::from("42"),
+                    username: String::from("42"),
+                    state: String::from("42"),
+                    avatar_url: None,
+                    web_url: String::from("42"),
+                },
+                sha: String::from("1d244937ee6ceb8e0314a4a201ba93a7a61f2071"),
+                web_url: String::from(""),
+                squash_commit_sha: None,
+                labels: vec![String::from("rust")],
+            })],
+        )?;
+        #[allow(deprecated)]
+        let expected_commits = vec![
+            Commit {
+                id: String::from("1d244937ee6ceb8e0314a4a201ba93a7a61f2071"),
+                message: String::from("add github integration"),
+                gitlab: RemoteContributor {
+                    username: Some(String::from("orhun")),
+                    pr_title: Some(String::from("1")),
+                    pr_number: Some(1),
+                    pr_labels: vec![String::from("rust")],
+                    is_first_time: false,
+                },
+                remote: Some(RemoteContributor {
+                    username: Some(String::from("orhun")),
+                    pr_title: Some(String::from("1")),
+                    pr_number: Some(1),
+                    pr_labels: vec![String::from("rust")],
+                    is_first_time: false,
+                }),
+                ..Default::default()
+            },
+            Commit {
+                id: String::from("21f6aa587fcb772de13f2fde0e92697c51f84162"),
+                message: String::from("fix github integration"),
+                gitlab: RemoteContributor {
+                    username: Some(String::from("orhun")),
+                    pr_title: None,
+                    pr_number: None,
+                    pr_labels: vec![],
+                    is_first_time: false,
+                },
+                remote: Some(RemoteContributor {
+                    username: Some(String::from("orhun")),
+                    pr_title: None,
+                    pr_number: None,
+                    pr_labels: vec![],
+                    is_first_time: false,
+                }),
+                ..Default::default()
+            },
+            Commit {
+                id: String::from("35d8c6b6329ecbcf131d7df02f93c3bbc5ba5973"),
+                message: String::from("update metadata"),
+                gitlab: RemoteContributor {
+                    username: Some(String::from("nuhro")),
+                    pr_title: None,
+                    pr_number: None,
+                    pr_labels: vec![],
+                    is_first_time: false,
+                },
+                remote: Some(RemoteContributor {
+                    username: Some(String::from("nuhro")),
+                    pr_title: None,
+                    pr_number: None,
+                    pr_labels: vec![],
+                    is_first_time: false,
+                }),
+                ..Default::default()
+            },
+            Commit {
+                id: String::from("4d3ffe4753b923f4d7807c490e650e6624a12074"),
+                message: String::from("do some stuff"),
+                gitlab: RemoteContributor {
+                    username: Some(String::from("awesome_contributor")),
+                    pr_title: None,
+                    pr_number: None,
+                    pr_labels: vec![],
+                    is_first_time: false,
+                },
+                remote: Some(RemoteContributor {
+                    username: Some(String::from("awesome_contributor")),
+                    pr_title: None,
+                    pr_number: None,
+                    pr_labels: vec![],
+                    is_first_time: false,
+                }),
+                ..Default::default()
+            },
+            Commit {
+                id: String::from("5a55e92e5a62dc5bf9872ffb2566959fad98bd05"),
+                message: String::from("alright"),
+                gitlab: RemoteContributor {
+                    username: Some(String::from("orhun")),
+                    pr_title: None,
+                    pr_number: None,
+                    pr_labels: vec![],
+                    is_first_time: false,
+                },
+                remote: Some(RemoteContributor {
+                    username: Some(String::from("orhun")),
+                    pr_title: None,
+                    pr_number: None,
+                    pr_labels: vec![],
+                    is_first_time: false,
+                }),
+                ..Default::default()
+            },
+            Commit {
+                id: String::from("6c34967147560ea09658776d4901709139b4ad66"),
+                message: String::from("should be fine"),
+                gitlab: RemoteContributor {
+                    username: Some(String::from("someone")),
+                    pr_title: None,
+                    pr_number: None,
+                    pr_labels: vec![],
+                    is_first_time: false,
+                },
+                remote: Some(RemoteContributor {
+                    username: Some(String::from("someone")),
+                    pr_title: None,
+                    pr_number: None,
+                    pr_labels: vec![],
+                    is_first_time: false,
+                }),
+                ..Default::default()
+            },
+        ];
+        assert_eq!(expected_commits, release.commits);
 
-		release
-			.github
-			.contributors
-			.sort_by(|a, b| a.pr_number.cmp(&b.pr_number));
+        release
+            .github
+            .contributors
+            .sort_by(|a, b| a.pr_number.cmp(&b.pr_number));
 
-		let expected_metadata = RemoteReleaseMetadata {
-			contributors: vec![
-				RemoteContributor {
-					username:      Some(String::from("orhun")),
-					pr_title:      Some(String::from("1")),
-					pr_number:     Some(1),
-					pr_labels:     vec![String::from("rust")],
-					is_first_time: false,
-				},
-				RemoteContributor {
-					username:      Some(String::from("nuhro")),
-					pr_title:      None,
-					pr_number:     None,
-					pr_labels:     vec![],
-					is_first_time: true,
-				},
-				RemoteContributor {
-					username:      Some(String::from("awesome_contributor")),
-					pr_title:      None,
-					pr_number:     None,
-					pr_labels:     vec![],
-					is_first_time: true,
-				},
-				RemoteContributor {
-					username:      Some(String::from("someone")),
-					pr_title:      None,
-					pr_number:     None,
-					pr_labels:     vec![],
-					is_first_time: true,
-				},
-			],
-		};
-		assert_eq!(expected_metadata, release.gitlab);
+        let expected_metadata = RemoteReleaseMetadata {
+            contributors: vec![
+                RemoteContributor {
+                    username: Some(String::from("orhun")),
+                    pr_title: Some(String::from("1")),
+                    pr_number: Some(1),
+                    pr_labels: vec![String::from("rust")],
+                    is_first_time: false,
+                },
+                RemoteContributor {
+                    username: Some(String::from("nuhro")),
+                    pr_title: None,
+                    pr_number: None,
+                    pr_labels: vec![],
+                    is_first_time: true,
+                },
+                RemoteContributor {
+                    username: Some(String::from("awesome_contributor")),
+                    pr_title: None,
+                    pr_number: None,
+                    pr_labels: vec![],
+                    is_first_time: true,
+                },
+                RemoteContributor {
+                    username: Some(String::from("someone")),
+                    pr_title: None,
+                    pr_number: None,
+                    pr_labels: vec![],
+                    is_first_time: true,
+                },
+            ],
+        };
+        assert_eq!(expected_metadata, release.gitlab);
 
-		Ok(())
-	}
+        Ok(())
+    }
 
-	#[cfg(feature = "gitea")]
-	#[test]
-	fn update_gitea_metadata() -> Result<()> {
-		use crate::remote::gitea::{
-			GiteaCommit,
-			GiteaCommitAuthor,
-			GiteaPullRequest,
-			PullRequestLabel,
-		};
+    #[cfg(feature = "gitea")]
+    #[test]
+    fn update_gitea_metadata() -> Result<()> {
+        use crate::remote::gitea::{
+            GiteaCommit, GiteaCommitAuthor, GiteaPullRequest, PullRequestLabel,
+        };
 
-		let mut release = Release {
-			version: None,
-			message: None,
-			extra: None,
-			commits: vec![
-				Commit::from(String::from(
-					"1d244937ee6ceb8e0314a4a201ba93a7a61f2071 add github \
+        let mut release = Release {
+            version: None,
+            message: None,
+            extra: None,
+            commits: vec![
+                Commit::from(String::from(
+                    "1d244937ee6ceb8e0314a4a201ba93a7a61f2071 add github \
 					 integration",
-				)),
-				Commit::from(String::from(
-					"21f6aa587fcb772de13f2fde0e92697c51f84162 fix github \
+                )),
+                Commit::from(String::from(
+                    "21f6aa587fcb772de13f2fde0e92697c51f84162 fix github \
 					 integration",
-				)),
-				Commit::from(String::from(
-					"35d8c6b6329ecbcf131d7df02f93c3bbc5ba5973 update metadata",
-				)),
-				Commit::from(String::from(
-					"4d3ffe4753b923f4d7807c490e650e6624a12074 do some stuff",
-				)),
-				Commit::from(String::from(
-					"5a55e92e5a62dc5bf9872ffb2566959fad98bd05 alright",
-				)),
-				Commit::from(String::from(
-					"6c34967147560ea09658776d4901709139b4ad66 should be fine",
-				)),
-			],
-			commit_id: None,
-			timestamp: 0,
-			previous: Some(Box::new(Release {
-				version: Some(String::from("1.0.0")),
-				..Default::default()
-			})),
-			repository: Some(String::from("/root/repo")),
-			#[cfg(feature = "github")]
-			github: RemoteReleaseMetadata {
-				contributors: vec![],
-			},
-			#[cfg(feature = "gitlab")]
-			gitlab: RemoteReleaseMetadata {
-				contributors: vec![],
-			},
-			#[cfg(feature = "gitea")]
-			gitea: RemoteReleaseMetadata {
-				contributors: vec![],
-			},
-			#[cfg(feature = "bitbucket")]
-			bitbucket: RemoteReleaseMetadata {
-				contributors: vec![],
-			},
-		};
-		release.update_gitea_metadata(
-			vec![
-				GiteaCommit {
-					sha:    String::from("1d244937ee6ceb8e0314a4a201ba93a7a61f2071"),
-					author: Some(GiteaCommitAuthor {
-						login: Some(String::from("orhun")),
-					}),
-				},
-				GiteaCommit {
-					sha:    String::from("21f6aa587fcb772de13f2fde0e92697c51f84162"),
-					author: Some(GiteaCommitAuthor {
-						login: Some(String::from("orhun")),
-					}),
-				},
-				GiteaCommit {
-					sha:    String::from("35d8c6b6329ecbcf131d7df02f93c3bbc5ba5973"),
-					author: Some(GiteaCommitAuthor {
-						login: Some(String::from("nuhro")),
-					}),
-				},
-				GiteaCommit {
-					sha:    String::from("4d3ffe4753b923f4d7807c490e650e6624a12074"),
-					author: Some(GiteaCommitAuthor {
-						login: Some(String::from("awesome_contributor")),
-					}),
-				},
-				GiteaCommit {
-					sha:    String::from("5a55e92e5a62dc5bf9872ffb2566959fad98bd05"),
-					author: Some(GiteaCommitAuthor {
-						login: Some(String::from("orhun")),
-					}),
-				},
-				GiteaCommit {
-					sha:    String::from("6c34967147560ea09658776d4901709139b4ad66"),
-					author: Some(GiteaCommitAuthor {
-						login: Some(String::from("someone")),
-					}),
-				},
-				GiteaCommit {
-					sha:    String::from("0c34967147560e809658776d4901709139b4ad68"),
-					author: Some(GiteaCommitAuthor {
-						login: Some(String::from("idk")),
-					}),
-				},
-				GiteaCommit {
-					sha:    String::from("kk34967147560e809658776d4901709139b4ad68"),
-					author: None,
-				},
-				GiteaCommit {
-					sha:    String::new(),
-					author: None,
-				},
-			]
-			.into_iter()
-			.map(|v| Box::new(v) as Box<dyn RemoteCommit>)
-			.collect(),
-			vec![
-				GiteaPullRequest {
-					title:            Some(String::from("1")),
-					number:           42,
-					merge_commit_sha: Some(String::from(
-						"1d244937ee6ceb8e0314a4a201ba93a7a61f2071",
-					)),
-					labels:           vec![PullRequestLabel {
-						name: String::from("rust"),
-					}],
-				},
-				GiteaPullRequest {
-					title:            Some(String::from("2")),
-					number:           66,
-					merge_commit_sha: Some(String::from(
-						"21f6aa587fcb772de13f2fde0e92697c51f84162",
-					)),
-					labels:           vec![PullRequestLabel {
-						name: String::from("rust"),
-					}],
-				},
-				GiteaPullRequest {
-					title:            Some(String::from("3")),
-					number:           53,
-					merge_commit_sha: Some(String::from(
-						"35d8c6b6329ecbcf131d7df02f93c3bbc5ba5973",
-					)),
-					labels:           vec![PullRequestLabel {
-						name: String::from("deps"),
-					}],
-				},
-				GiteaPullRequest {
-					title:            Some(String::from("4")),
-					number:           1000,
-					merge_commit_sha: Some(String::from(
-						"4d3ffe4753b923f4d7807c490e650e6624a12074",
-					)),
-					labels:           vec![PullRequestLabel {
-						name: String::from("deps"),
-					}],
-				},
-				GiteaPullRequest {
-					title:            Some(String::from("5")),
-					number:           999999,
-					merge_commit_sha: Some(String::from(
-						"5a55e92e5a62dc5bf9872ffb2566959fad98bd05",
-					)),
-					labels:           vec![PullRequestLabel {
-						name: String::from("github"),
-					}],
-				},
-			]
-			.into_iter()
-			.map(|v| Box::new(v) as Box<dyn RemotePullRequest>)
-			.collect(),
-		)?;
-		#[allow(deprecated)]
-		let expected_commits = vec![
-			Commit {
-				id: String::from("1d244937ee6ceb8e0314a4a201ba93a7a61f2071"),
-				message: String::from("add github integration"),
-				gitea: RemoteContributor {
-					username:      Some(String::from("orhun")),
-					pr_title:      Some(String::from("1")),
-					pr_number:     Some(42),
-					pr_labels:     vec![String::from("rust")],
-					is_first_time: false,
-				},
-				remote: Some(RemoteContributor {
-					username:      Some(String::from("orhun")),
-					pr_title:      Some(String::from("1")),
-					pr_number:     Some(42),
-					pr_labels:     vec![String::from("rust")],
-					is_first_time: false,
-				}),
-				..Default::default()
-			},
-			Commit {
-				id: String::from("21f6aa587fcb772de13f2fde0e92697c51f84162"),
-				message: String::from("fix github integration"),
-				gitea: RemoteContributor {
-					username:      Some(String::from("orhun")),
-					pr_title:      Some(String::from("2")),
-					pr_number:     Some(66),
-					pr_labels:     vec![String::from("rust")],
-					is_first_time: false,
-				},
-				remote: Some(RemoteContributor {
-					username:      Some(String::from("orhun")),
-					pr_title:      Some(String::from("2")),
-					pr_number:     Some(66),
-					pr_labels:     vec![String::from("rust")],
-					is_first_time: false,
-				}),
-				..Default::default()
-			},
-			Commit {
-				id: String::from("35d8c6b6329ecbcf131d7df02f93c3bbc5ba5973"),
-				message: String::from("update metadata"),
-				gitea: RemoteContributor {
-					username:      Some(String::from("nuhro")),
-					pr_title:      Some(String::from("3")),
-					pr_number:     Some(53),
-					pr_labels:     vec![String::from("deps")],
-					is_first_time: false,
-				},
-				remote: Some(RemoteContributor {
-					username:      Some(String::from("nuhro")),
-					pr_title:      Some(String::from("3")),
-					pr_number:     Some(53),
-					pr_labels:     vec![String::from("deps")],
-					is_first_time: false,
-				}),
-				..Default::default()
-			},
-			Commit {
-				id: String::from("4d3ffe4753b923f4d7807c490e650e6624a12074"),
-				message: String::from("do some stuff"),
-				gitea: RemoteContributor {
-					username:      Some(String::from("awesome_contributor")),
-					pr_title:      Some(String::from("4")),
-					pr_number:     Some(1000),
-					pr_labels:     vec![String::from("deps")],
-					is_first_time: false,
-				},
-				remote: Some(RemoteContributor {
-					username:      Some(String::from("awesome_contributor")),
-					pr_title:      Some(String::from("4")),
-					pr_number:     Some(1000),
-					pr_labels:     vec![String::from("deps")],
-					is_first_time: false,
-				}),
-				..Default::default()
-			},
-			Commit {
-				id: String::from("5a55e92e5a62dc5bf9872ffb2566959fad98bd05"),
-				message: String::from("alright"),
-				gitea: RemoteContributor {
-					username:      Some(String::from("orhun")),
-					pr_title:      Some(String::from("5")),
-					pr_number:     Some(999999),
-					pr_labels:     vec![String::from("github")],
-					is_first_time: false,
-				},
-				remote: Some(RemoteContributor {
-					username:      Some(String::from("orhun")),
-					pr_title:      Some(String::from("5")),
-					pr_number:     Some(999999),
-					pr_labels:     vec![String::from("github")],
-					is_first_time: false,
-				}),
-				..Default::default()
-			},
-			Commit {
-				id: String::from("6c34967147560ea09658776d4901709139b4ad66"),
-				message: String::from("should be fine"),
-				gitea: RemoteContributor {
-					username:      Some(String::from("someone")),
-					pr_title:      None,
-					pr_number:     None,
-					pr_labels:     vec![],
-					is_first_time: false,
-				},
-				remote: Some(RemoteContributor {
-					username:      Some(String::from("someone")),
-					pr_title:      None,
-					pr_number:     None,
-					pr_labels:     vec![],
-					is_first_time: false,
-				}),
-				..Default::default()
-			},
-		];
-		assert_eq!(expected_commits, release.commits);
+                )),
+                Commit::from(String::from(
+                    "35d8c6b6329ecbcf131d7df02f93c3bbc5ba5973 update metadata",
+                )),
+                Commit::from(String::from(
+                    "4d3ffe4753b923f4d7807c490e650e6624a12074 do some stuff",
+                )),
+                Commit::from(String::from(
+                    "5a55e92e5a62dc5bf9872ffb2566959fad98bd05 alright",
+                )),
+                Commit::from(String::from(
+                    "6c34967147560ea09658776d4901709139b4ad66 should be fine",
+                )),
+            ],
+            commit_id: None,
+            timestamp: 0,
+            previous: Some(Box::new(Release {
+                version: Some(String::from("1.0.0")),
+                ..Default::default()
+            })),
+            repository: Some(String::from("/root/repo")),
+            #[cfg(feature = "github")]
+            github: RemoteReleaseMetadata {
+                contributors: vec![],
+            },
+            #[cfg(feature = "gitlab")]
+            gitlab: RemoteReleaseMetadata {
+                contributors: vec![],
+            },
+            #[cfg(feature = "gitea")]
+            gitea: RemoteReleaseMetadata {
+                contributors: vec![],
+            },
+            #[cfg(feature = "bitbucket")]
+            bitbucket: RemoteReleaseMetadata {
+                contributors: vec![],
+            },
+        };
+        release.update_gitea_metadata(
+            vec![
+                GiteaCommit {
+                    sha: String::from("1d244937ee6ceb8e0314a4a201ba93a7a61f2071"),
+                    author: Some(GiteaCommitAuthor {
+                        login: Some(String::from("orhun")),
+                    }),
+                },
+                GiteaCommit {
+                    sha: String::from("21f6aa587fcb772de13f2fde0e92697c51f84162"),
+                    author: Some(GiteaCommitAuthor {
+                        login: Some(String::from("orhun")),
+                    }),
+                },
+                GiteaCommit {
+                    sha: String::from("35d8c6b6329ecbcf131d7df02f93c3bbc5ba5973"),
+                    author: Some(GiteaCommitAuthor {
+                        login: Some(String::from("nuhro")),
+                    }),
+                },
+                GiteaCommit {
+                    sha: String::from("4d3ffe4753b923f4d7807c490e650e6624a12074"),
+                    author: Some(GiteaCommitAuthor {
+                        login: Some(String::from("awesome_contributor")),
+                    }),
+                },
+                GiteaCommit {
+                    sha: String::from("5a55e92e5a62dc5bf9872ffb2566959fad98bd05"),
+                    author: Some(GiteaCommitAuthor {
+                        login: Some(String::from("orhun")),
+                    }),
+                },
+                GiteaCommit {
+                    sha: String::from("6c34967147560ea09658776d4901709139b4ad66"),
+                    author: Some(GiteaCommitAuthor {
+                        login: Some(String::from("someone")),
+                    }),
+                },
+                GiteaCommit {
+                    sha: String::from("0c34967147560e809658776d4901709139b4ad68"),
+                    author: Some(GiteaCommitAuthor {
+                        login: Some(String::from("idk")),
+                    }),
+                },
+                GiteaCommit {
+                    sha: String::from("kk34967147560e809658776d4901709139b4ad68"),
+                    author: None,
+                },
+                GiteaCommit {
+                    sha: String::new(),
+                    author: None,
+                },
+            ]
+            .into_iter()
+            .map(|v| Box::new(v) as Box<dyn RemoteCommit>)
+            .collect(),
+            vec![
+                GiteaPullRequest {
+                    title: Some(String::from("1")),
+                    number: 42,
+                    merge_commit_sha: Some(String::from(
+                        "1d244937ee6ceb8e0314a4a201ba93a7a61f2071",
+                    )),
+                    labels: vec![PullRequestLabel {
+                        name: String::from("rust"),
+                    }],
+                },
+                GiteaPullRequest {
+                    title: Some(String::from("2")),
+                    number: 66,
+                    merge_commit_sha: Some(String::from(
+                        "21f6aa587fcb772de13f2fde0e92697c51f84162",
+                    )),
+                    labels: vec![PullRequestLabel {
+                        name: String::from("rust"),
+                    }],
+                },
+                GiteaPullRequest {
+                    title: Some(String::from("3")),
+                    number: 53,
+                    merge_commit_sha: Some(String::from(
+                        "35d8c6b6329ecbcf131d7df02f93c3bbc5ba5973",
+                    )),
+                    labels: vec![PullRequestLabel {
+                        name: String::from("deps"),
+                    }],
+                },
+                GiteaPullRequest {
+                    title: Some(String::from("4")),
+                    number: 1000,
+                    merge_commit_sha: Some(String::from(
+                        "4d3ffe4753b923f4d7807c490e650e6624a12074",
+                    )),
+                    labels: vec![PullRequestLabel {
+                        name: String::from("deps"),
+                    }],
+                },
+                GiteaPullRequest {
+                    title: Some(String::from("5")),
+                    number: 999999,
+                    merge_commit_sha: Some(String::from(
+                        "5a55e92e5a62dc5bf9872ffb2566959fad98bd05",
+                    )),
+                    labels: vec![PullRequestLabel {
+                        name: String::from("github"),
+                    }],
+                },
+            ]
+            .into_iter()
+            .map(|v| Box::new(v) as Box<dyn RemotePullRequest>)
+            .collect(),
+        )?;
+        #[allow(deprecated)]
+        let expected_commits = vec![
+            Commit {
+                id: String::from("1d244937ee6ceb8e0314a4a201ba93a7a61f2071"),
+                message: String::from("add github integration"),
+                gitea: RemoteContributor {
+                    username: Some(String::from("orhun")),
+                    pr_title: Some(String::from("1")),
+                    pr_number: Some(42),
+                    pr_labels: vec![String::from("rust")],
+                    is_first_time: false,
+                },
+                remote: Some(RemoteContributor {
+                    username: Some(String::from("orhun")),
+                    pr_title: Some(String::from("1")),
+                    pr_number: Some(42),
+                    pr_labels: vec![String::from("rust")],
+                    is_first_time: false,
+                }),
+                ..Default::default()
+            },
+            Commit {
+                id: String::from("21f6aa587fcb772de13f2fde0e92697c51f84162"),
+                message: String::from("fix github integration"),
+                gitea: RemoteContributor {
+                    username: Some(String::from("orhun")),
+                    pr_title: Some(String::from("2")),
+                    pr_number: Some(66),
+                    pr_labels: vec![String::from("rust")],
+                    is_first_time: false,
+                },
+                remote: Some(RemoteContributor {
+                    username: Some(String::from("orhun")),
+                    pr_title: Some(String::from("2")),
+                    pr_number: Some(66),
+                    pr_labels: vec![String::from("rust")],
+                    is_first_time: false,
+                }),
+                ..Default::default()
+            },
+            Commit {
+                id: String::from("35d8c6b6329ecbcf131d7df02f93c3bbc5ba5973"),
+                message: String::from("update metadata"),
+                gitea: RemoteContributor {
+                    username: Some(String::from("nuhro")),
+                    pr_title: Some(String::from("3")),
+                    pr_number: Some(53),
+                    pr_labels: vec![String::from("deps")],
+                    is_first_time: false,
+                },
+                remote: Some(RemoteContributor {
+                    username: Some(String::from("nuhro")),
+                    pr_title: Some(String::from("3")),
+                    pr_number: Some(53),
+                    pr_labels: vec![String::from("deps")],
+                    is_first_time: false,
+                }),
+                ..Default::default()
+            },
+            Commit {
+                id: String::from("4d3ffe4753b923f4d7807c490e650e6624a12074"),
+                message: String::from("do some stuff"),
+                gitea: RemoteContributor {
+                    username: Some(String::from("awesome_contributor")),
+                    pr_title: Some(String::from("4")),
+                    pr_number: Some(1000),
+                    pr_labels: vec![String::from("deps")],
+                    is_first_time: false,
+                },
+                remote: Some(RemoteContributor {
+                    username: Some(String::from("awesome_contributor")),
+                    pr_title: Some(String::from("4")),
+                    pr_number: Some(1000),
+                    pr_labels: vec![String::from("deps")],
+                    is_first_time: false,
+                }),
+                ..Default::default()
+            },
+            Commit {
+                id: String::from("5a55e92e5a62dc5bf9872ffb2566959fad98bd05"),
+                message: String::from("alright"),
+                gitea: RemoteContributor {
+                    username: Some(String::from("orhun")),
+                    pr_title: Some(String::from("5")),
+                    pr_number: Some(999999),
+                    pr_labels: vec![String::from("github")],
+                    is_first_time: false,
+                },
+                remote: Some(RemoteContributor {
+                    username: Some(String::from("orhun")),
+                    pr_title: Some(String::from("5")),
+                    pr_number: Some(999999),
+                    pr_labels: vec![String::from("github")],
+                    is_first_time: false,
+                }),
+                ..Default::default()
+            },
+            Commit {
+                id: String::from("6c34967147560ea09658776d4901709139b4ad66"),
+                message: String::from("should be fine"),
+                gitea: RemoteContributor {
+                    username: Some(String::from("someone")),
+                    pr_title: None,
+                    pr_number: None,
+                    pr_labels: vec![],
+                    is_first_time: false,
+                },
+                remote: Some(RemoteContributor {
+                    username: Some(String::from("someone")),
+                    pr_title: None,
+                    pr_number: None,
+                    pr_labels: vec![],
+                    is_first_time: false,
+                }),
+                ..Default::default()
+            },
+        ];
+        assert_eq!(expected_commits, release.commits);
 
-		release
-			.gitea
-			.contributors
-			.sort_by(|a, b| a.pr_number.cmp(&b.pr_number));
+        release
+            .gitea
+            .contributors
+            .sort_by(|a, b| a.pr_number.cmp(&b.pr_number));
 
-		let expected_metadata = RemoteReleaseMetadata {
-			contributors: vec![
-				RemoteContributor {
-					username:      Some(String::from("someone")),
-					pr_title:      None,
-					pr_number:     None,
-					pr_labels:     vec![],
-					is_first_time: true,
-				},
-				RemoteContributor {
-					username:      Some(String::from("orhun")),
-					pr_title:      Some(String::from("1")),
-					pr_number:     Some(42),
-					pr_labels:     vec![String::from("rust")],
-					is_first_time: true,
-				},
-				RemoteContributor {
-					username:      Some(String::from("nuhro")),
-					pr_title:      Some(String::from("3")),
-					pr_number:     Some(53),
-					pr_labels:     vec![String::from("deps")],
-					is_first_time: true,
-				},
-				RemoteContributor {
-					username:      Some(String::from("awesome_contributor")),
-					pr_title:      Some(String::from("4")),
-					pr_number:     Some(1000),
-					pr_labels:     vec![String::from("deps")],
-					is_first_time: true,
-				},
-			],
-		};
-		assert_eq!(expected_metadata, release.gitea);
+        let expected_metadata = RemoteReleaseMetadata {
+            contributors: vec![
+                RemoteContributor {
+                    username: Some(String::from("someone")),
+                    pr_title: None,
+                    pr_number: None,
+                    pr_labels: vec![],
+                    is_first_time: true,
+                },
+                RemoteContributor {
+                    username: Some(String::from("orhun")),
+                    pr_title: Some(String::from("1")),
+                    pr_number: Some(42),
+                    pr_labels: vec![String::from("rust")],
+                    is_first_time: true,
+                },
+                RemoteContributor {
+                    username: Some(String::from("nuhro")),
+                    pr_title: Some(String::from("3")),
+                    pr_number: Some(53),
+                    pr_labels: vec![String::from("deps")],
+                    is_first_time: true,
+                },
+                RemoteContributor {
+                    username: Some(String::from("awesome_contributor")),
+                    pr_title: Some(String::from("4")),
+                    pr_number: Some(1000),
+                    pr_labels: vec![String::from("deps")],
+                    is_first_time: true,
+                },
+            ],
+        };
+        assert_eq!(expected_metadata, release.gitea);
 
-		Ok(())
-	}
+        Ok(())
+    }
 }
diff --git a/git-cliff-core/src/remote/bitbucket.rs b/git-cliff-core/src/remote/bitbucket.rs
index f45a47cfe7..401e3f1f07 100644
--- a/git-cliff-core/src/remote/bitbucket.rs
+++ b/git-cliff-core/src/remote/bitbucket.rs
@@ -1,10 +1,7 @@
 use crate::config::Remote;
 use crate::error::*;
 use reqwest_middleware::ClientWithMiddleware;
-use serde::{
-	Deserialize,
-	Serialize,
-};
+use serde::{Deserialize, Serialize};
 use std::env;
 
 use super::*;
@@ -22,8 +19,7 @@ pub const START_FETCHING_MSG: &str = "Retrieving data from Bitbucket...";
 pub const FINISHED_FETCHING_MSG: &str = "Done fetching Bitbucket data.";
 
 /// Template variables related to this remote.
-pub(crate) const TEMPLATE_VARIABLES: &[&str] =
-	&["bitbucket", "commit.bitbucket", "commit.remote"];
+pub(crate) const TEMPLATE_VARIABLES: &[&str] = &["bitbucket", "commit.bitbucket", "commit.remote"];
 
 /// Maximum number of entries to fetch for bitbucket pull requests.
 pub(crate) const BITBUCKET_MAX_PAGE_PRS: usize = 50;
@@ -31,39 +27,39 @@ pub(crate) const BITBUCKET_MAX_PAGE_PRS: usize = 50;
 /// Representation of a single commit.
 #[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
 pub struct BitbucketCommit {
-	/// SHA.
-	pub hash:   String,
-	/// Author of the commit.
-	pub author: Option<BitbucketCommitAuthor>,
+    /// SHA.
+    pub hash: String,
+    /// Author of the commit.
+    pub author: Option<BitbucketCommitAuthor>,
 }
 
 impl RemoteCommit for BitbucketCommit {
-	fn id(&self) -> String {
-		self.hash.clone()
-	}
+    fn id(&self) -> String {
+        self.hash.clone()
+    }
 
-	fn username(&self) -> Option<String> {
-		self.author.clone().and_then(|v| v.login)
-	}
+    fn username(&self) -> Option<String> {
+        self.author.clone().and_then(|v| v.login)
+    }
 }
 
 /// <https://developer.atlassian.com/cloud/bitbucket/rest/api-group-commits/#api-repositories-workspace-repo-slug-commits-get>
 impl RemoteEntry for BitbucketPagination<BitbucketCommit> {
-	fn url(_id: i64, api_url: &str, remote: &Remote, page: i32) -> String {
-		let commit_page = page + 1;
-		format!(
-			"{}/{}/{}/commits?pagelen={MAX_PAGE_SIZE}&page={commit_page}",
-			api_url, remote.owner, remote.repo
-		)
-	}
-
-	fn buffer_size() -> usize {
-		10
-	}
-
-	fn early_exit(&self) -> bool {
-		self.values.is_empty()
-	}
+    fn url(_id: i64, api_url: &str, remote: &Remote, page: i32) -> String {
+        let commit_page = page + 1;
+        format!(
+            "{}/{}/{}/commits?pagelen={MAX_PAGE_SIZE}&page={commit_page}",
+            api_url, remote.owner, remote.repo
+        )
+    }
+
+    fn buffer_size() -> usize {
+        10
+    }
+
+    fn early_exit(&self) -> bool {
+        self.values.is_empty()
+    }
 }
 
 /// Bitbucket Pagination Header
@@ -71,153 +67,151 @@ impl RemoteEntry for BitbucketPagination<BitbucketCommit> {
 /// <https://developer.atlassian.com/cloud/bitbucket/rest/intro/#pagination>
 #[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
 pub struct BitbucketPagination<T> {
-	/// Total number of objects in the response.
-	pub size:     Option<i64>,
-	/// Page number of the current results.
-	pub page:     Option<i64>,
-	/// Current number of objects on the existing page.  Globally, the minimum
-	/// length is 10 and the maximum is 100.
-	pub pagelen:  Option<i64>,
-	/// Link to the next page if it exists.
-	pub next:     Option<String>,
-	/// Link to the previous page if it exists.
-	pub previous: Option<String>,
-	/// List of Objects.
-	pub values:   Vec<T>,
+    /// Total number of objects in the response.
+    pub size: Option<i64>,
+    /// Page number of the current results.
+    pub page: Option<i64>,
+    /// Current number of objects on the existing page.  Globally, the minimum
+    /// length is 10 and the maximum is 100.
+    pub pagelen: Option<i64>,
+    /// Link to the next page if it exists.
+    pub next: Option<String>,
+    /// Link to the previous page if it exists.
+    pub previous: Option<String>,
+    /// List of Objects.
+    pub values: Vec<T>,
 }
 
 /// Author of the commit.
 #[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
 pub struct BitbucketCommitAuthor {
-	/// Username.
-	#[serde(rename = "raw")]
-	pub login: Option<String>,
+    /// Username.
+    #[serde(rename = "raw")]
+    pub login: Option<String>,
 }
 
 /// Label of the pull request.
 #[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct PullRequestLabel {
-	/// Name of the label.
-	pub name: String,
+    /// Name of the label.
+    pub name: String,
 }
 
 /// Representation of a single pull request's merge commit
 #[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
 pub struct BitbucketPullRequestMergeCommit {
-	/// SHA of the merge commit.
-	pub hash: String,
+    /// SHA of the merge commit.
+    pub hash: String,
 }
 
 /// Representation of a single pull request.
 #[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
 pub struct BitbucketPullRequest {
-	/// Pull request number.
-	pub id:               i64,
-	/// Pull request title.
-	pub title:            Option<String>,
-	/// Bitbucket Pull Request Merge Commit
-	pub merge_commit_sha: BitbucketPullRequestMergeCommit,
-	/// Author of Pull Request
-	pub author:           BitbucketCommitAuthor,
+    /// Pull request number.
+    pub id: i64,
+    /// Pull request title.
+    pub title: Option<String>,
+    /// Bitbucket Pull Request Merge Commit
+    pub merge_commit_sha: BitbucketPullRequestMergeCommit,
+    /// Author of Pull Request
+    pub author: BitbucketCommitAuthor,
 }
 
 impl RemotePullRequest for BitbucketPullRequest {
-	fn number(&self) -> i64 {
-		self.id
-	}
+    fn number(&self) -> i64 {
+        self.id
+    }
 
-	fn title(&self) -> Option<String> {
-		self.title.clone()
-	}
+    fn title(&self) -> Option<String> {
+        self.title.clone()
+    }
 
-	fn labels(&self) -> Vec<String> {
-		vec![]
-	}
+    fn labels(&self) -> Vec<String> {
+        vec![]
+    }
 
-	fn merge_commit(&self) -> Option<String> {
-		Some(self.merge_commit_sha.hash.clone())
-	}
+    fn merge_commit(&self) -> Option<String> {
+        Some(self.merge_commit_sha.hash.clone())
+    }
 }
 
 /// <https://developer.atlassian.com/cloud/bitbucket/rest/api-group-pullrequests/#api-repositories-workspace-repo-slug-pullrequests-get>
 impl RemoteEntry for BitbucketPagination<BitbucketPullRequest> {
-	fn url(_id: i64, api_url: &str, remote: &Remote, page: i32) -> String {
-		let pr_page = page + 1;
-		format!(
-			"{}/{}/{}/pullrequests?&pagelen={BITBUCKET_MAX_PAGE_PRS}&\
+    fn url(_id: i64, api_url: &str, remote: &Remote, page: i32) -> String {
+        let pr_page = page + 1;
+        format!(
+            "{}/{}/{}/pullrequests?&pagelen={BITBUCKET_MAX_PAGE_PRS}&\
 			 page={pr_page}&state=MERGED",
-			api_url, remote.owner, remote.repo
-		)
-	}
+            api_url, remote.owner, remote.repo
+        )
+    }
 
-	fn buffer_size() -> usize {
-		5
-	}
+    fn buffer_size() -> usize {
+        5
+    }
 
-	fn early_exit(&self) -> bool {
-		self.values.is_empty()
-	}
+    fn early_exit(&self) -> bool {
+        self.values.is_empty()
+    }
 }
 
 /// HTTP client for handling Bitbucket REST API requests.
 #[derive(Debug, Clone)]
 pub struct BitbucketClient {
-	/// Remote.
-	remote: Remote,
-	/// HTTP client.
-	client: ClientWithMiddleware,
+    /// Remote.
+    remote: Remote,
+    /// HTTP client.
+    client: ClientWithMiddleware,
 }
 
 /// Constructs a Bitbucket client from the remote configuration.
 impl TryFrom<Remote> for BitbucketClient {
-	type Error = Error;
-	fn try_from(remote: Remote) -> Result<Self> {
-		Ok(Self {
-			client: create_remote_client(&remote, "application/json")?,
-			remote,
-		})
-	}
+    type Error = Error;
+    fn try_from(remote: Remote) -> Result<Self> {
+        Ok(Self {
+            client: create_remote_client(&remote, "application/json")?,
+            remote,
+        })
+    }
 }
 
 impl RemoteClient for BitbucketClient {
-	fn api_url() -> String {
-		env::var(BITBUCKET_API_URL_ENV)
-			.ok()
-			.unwrap_or_else(|| BITBUCKET_API_URL.to_string())
-	}
-
-	fn remote(&self) -> Remote {
-		self.remote.clone()
-	}
-
-	fn client(&self) -> ClientWithMiddleware {
-		self.client.clone()
-	}
+    fn api_url() -> String {
+        env::var(BITBUCKET_API_URL_ENV)
+            .ok()
+            .unwrap_or_else(|| BITBUCKET_API_URL.to_string())
+    }
+
+    fn remote(&self) -> Remote {
+        self.remote.clone()
+    }
+
+    fn client(&self) -> ClientWithMiddleware {
+        self.client.clone()
+    }
 }
 
 impl BitbucketClient {
-	/// Fetches the Bitbucket API and returns the commits.
-	pub async fn get_commits(&self) -> Result<Vec<Box<dyn RemoteCommit>>> {
-		Ok(self
-			.fetch_with_early_exit::<BitbucketPagination<BitbucketCommit>>(0)
-			.await?
-			.into_iter()
-			.flat_map(|v| v.values)
-			.map(|v| Box::new(v) as Box<dyn RemoteCommit>)
-			.collect())
-	}
-
-	/// Fetches the Bitbucket API and returns the pull requests.
-	pub async fn get_pull_requests(
-		&self,
-	) -> Result<Vec<Box<dyn RemotePullRequest>>> {
-		Ok(self
-			.fetch_with_early_exit::<BitbucketPagination<BitbucketPullRequest>>(0)
-			.await?
-			.into_iter()
-			.flat_map(|v| v.values)
-			.map(|v| Box::new(v) as Box<dyn RemotePullRequest>)
-			.collect())
-	}
+    /// Fetches the Bitbucket API and returns the commits.
+    pub async fn get_commits(&self) -> Result<Vec<Box<dyn RemoteCommit>>> {
+        Ok(self
+            .fetch_with_early_exit::<BitbucketPagination<BitbucketCommit>>(0)
+            .await?
+            .into_iter()
+            .flat_map(|v| v.values)
+            .map(|v| Box::new(v) as Box<dyn RemoteCommit>)
+            .collect())
+    }
+
+    /// Fetches the Bitbucket API and returns the pull requests.
+    pub async fn get_pull_requests(&self) -> Result<Vec<Box<dyn RemotePullRequest>>> {
+        Ok(self
+            .fetch_with_early_exit::<BitbucketPagination<BitbucketPullRequest>>(0)
+            .await?
+            .into_iter()
+            .flat_map(|v| v.values)
+            .map(|v| Box::new(v) as Box<dyn RemotePullRequest>)
+            .collect())
+    }
 }
diff --git a/git-cliff-core/src/remote/gitea.rs b/git-cliff-core/src/remote/gitea.rs
index f6df6b2e30..6e11f8e027 100644
--- a/git-cliff-core/src/remote/gitea.rs
+++ b/git-cliff-core/src/remote/gitea.rs
@@ -1,10 +1,7 @@
 use crate::config::Remote;
 use crate::error::*;
 use reqwest_middleware::ClientWithMiddleware;
-use serde::{
-	Deserialize,
-	Serialize,
-};
+use serde::{Deserialize, Serialize};
 use std::env;
 
 use super::*;
@@ -22,164 +19,161 @@ pub const START_FETCHING_MSG: &str = "Retrieving data from Gitea...";
 pub const FINISHED_FETCHING_MSG: &str = "Done fetching Gitea data.";
 
 /// Template variables related to this remote.
-pub(crate) const TEMPLATE_VARIABLES: &[&str] =
-	&["gitea", "commit.gitea", "commit.remote"];
+pub(crate) const TEMPLATE_VARIABLES: &[&str] = &["gitea", "commit.gitea", "commit.remote"];
 
 /// Representation of a single commit.
 #[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
 pub struct GiteaCommit {
-	/// SHA.
-	pub sha:    String,
-	/// Author of the commit.
-	pub author: Option<GiteaCommitAuthor>,
+    /// SHA.
+    pub sha: String,
+    /// Author of the commit.
+    pub author: Option<GiteaCommitAuthor>,
 }
 
 impl RemoteCommit for GiteaCommit {
-	fn id(&self) -> String {
-		self.sha.clone()
-	}
+    fn id(&self) -> String {
+        self.sha.clone()
+    }
 
-	fn username(&self) -> Option<String> {
-		self.author.clone().and_then(|v| v.login)
-	}
+    fn username(&self) -> Option<String> {
+        self.author.clone().and_then(|v| v.login)
+    }
 }
 
 impl RemoteEntry for GiteaCommit {
-	fn url(_id: i64, api_url: &str, remote: &Remote, page: i32) -> String {
-		format!(
-			"{}/api/v1/repos/{}/{}/commits?limit={MAX_PAGE_SIZE}&page={page}",
-			api_url, remote.owner, remote.repo
-		)
-	}
-	fn buffer_size() -> usize {
-		10
-	}
-
-	fn early_exit(&self) -> bool {
-		false
-	}
+    fn url(_id: i64, api_url: &str, remote: &Remote, page: i32) -> String {
+        format!(
+            "{}/api/v1/repos/{}/{}/commits?limit={MAX_PAGE_SIZE}&page={page}",
+            api_url, remote.owner, remote.repo
+        )
+    }
+    fn buffer_size() -> usize {
+        10
+    }
+
+    fn early_exit(&self) -> bool {
+        false
+    }
 }
 
 /// Author of the commit.
 #[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
 pub struct GiteaCommitAuthor {
-	/// Username.
-	pub login: Option<String>,
+    /// Username.
+    pub login: Option<String>,
 }
 
 /// Label of the pull request.
 #[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct PullRequestLabel {
-	/// Name of the label.
-	pub name: String,
+    /// Name of the label.
+    pub name: String,
 }
 
 /// Representation of a single pull request.
 #[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
 pub struct GiteaPullRequest {
-	/// Pull request number.
-	pub number:           i64,
-	/// Pull request title.
-	pub title:            Option<String>,
-	/// SHA of the merge commit.
-	pub merge_commit_sha: Option<String>,
-	/// Labels of the pull request.
-	pub labels:           Vec<PullRequestLabel>,
+    /// Pull request number.
+    pub number: i64,
+    /// Pull request title.
+    pub title: Option<String>,
+    /// SHA of the merge commit.
+    pub merge_commit_sha: Option<String>,
+    /// Labels of the pull request.
+    pub labels: Vec<PullRequestLabel>,
 }
 
 impl RemotePullRequest for GiteaPullRequest {
-	fn number(&self) -> i64 {
-		self.number
-	}
+    fn number(&self) -> i64 {
+        self.number
+    }
 
-	fn title(&self) -> Option<String> {
-		self.title.clone()
-	}
+    fn title(&self) -> Option<String> {
+        self.title.clone()
+    }
 
-	fn labels(&self) -> Vec<String> {
-		self.labels.iter().map(|v| v.name.clone()).collect()
-	}
+    fn labels(&self) -> Vec<String> {
+        self.labels.iter().map(|v| v.name.clone()).collect()
+    }
 
-	fn merge_commit(&self) -> Option<String> {
-		self.merge_commit_sha.clone()
-	}
+    fn merge_commit(&self) -> Option<String> {
+        self.merge_commit_sha.clone()
+    }
 }
 
 impl RemoteEntry for GiteaPullRequest {
-	fn url(_id: i64, api_url: &str, remote: &Remote, page: i32) -> String {
-		format!(
-			"{}/api/v1/repos/{}/{}/pulls?limit={MAX_PAGE_SIZE}&page={page}&\
+    fn url(_id: i64, api_url: &str, remote: &Remote, page: i32) -> String {
+        format!(
+            "{}/api/v1/repos/{}/{}/pulls?limit={MAX_PAGE_SIZE}&page={page}&\
 			 state=closed",
-			api_url, remote.owner, remote.repo
-		)
-	}
+            api_url, remote.owner, remote.repo
+        )
+    }
 
-	fn buffer_size() -> usize {
-		5
-	}
+    fn buffer_size() -> usize {
+        5
+    }
 
-	fn early_exit(&self) -> bool {
-		false
-	}
+    fn early_exit(&self) -> bool {
+        false
+    }
 }
 
 /// HTTP client for handling Gitea REST API requests.
 #[derive(Debug, Clone)]
 pub struct GiteaClient {
-	/// Remote.
-	remote: Remote,
-	/// HTTP client.
-	client: ClientWithMiddleware,
+    /// Remote.
+    remote: Remote,
+    /// HTTP client.
+    client: ClientWithMiddleware,
 }
 
 /// Constructs a Gitea client from the remote configuration.
 impl TryFrom<Remote> for GiteaClient {
-	type Error = Error;
-	fn try_from(remote: Remote) -> Result<Self> {
-		Ok(Self {
-			client: create_remote_client(&remote, "application/json")?,
-			remote,
-		})
-	}
+    type Error = Error;
+    fn try_from(remote: Remote) -> Result<Self> {
+        Ok(Self {
+            client: create_remote_client(&remote, "application/json")?,
+            remote,
+        })
+    }
 }
 
 impl RemoteClient for GiteaClient {
-	fn api_url() -> String {
-		env::var(GITEA_API_URL_ENV)
-			.ok()
-			.unwrap_or_else(|| GITEA_API_URL.to_string())
-	}
-
-	fn remote(&self) -> Remote {
-		self.remote.clone()
-	}
-
-	fn client(&self) -> ClientWithMiddleware {
-		self.client.clone()
-	}
+    fn api_url() -> String {
+        env::var(GITEA_API_URL_ENV)
+            .ok()
+            .unwrap_or_else(|| GITEA_API_URL.to_string())
+    }
+
+    fn remote(&self) -> Remote {
+        self.remote.clone()
+    }
+
+    fn client(&self) -> ClientWithMiddleware {
+        self.client.clone()
+    }
 }
 
 impl GiteaClient {
-	/// Fetches the Gitea API and returns the commits.
-	pub async fn get_commits(&self) -> Result<Vec<Box<dyn RemoteCommit>>> {
-		Ok(self
-			.fetch::<GiteaCommit>(0)
-			.await?
-			.into_iter()
-			.map(|v| Box::new(v) as Box<dyn RemoteCommit>)
-			.collect())
-	}
-
-	/// Fetches the Gitea API and returns the pull requests.
-	pub async fn get_pull_requests(
-		&self,
-	) -> Result<Vec<Box<dyn RemotePullRequest>>> {
-		Ok(self
-			.fetch::<GiteaPullRequest>(0)
-			.await?
-			.into_iter()
-			.map(|v| Box::new(v) as Box<dyn RemotePullRequest>)
-			.collect())
-	}
+    /// Fetches the Gitea API and returns the commits.
+    pub async fn get_commits(&self) -> Result<Vec<Box<dyn RemoteCommit>>> {
+        Ok(self
+            .fetch::<GiteaCommit>(0)
+            .await?
+            .into_iter()
+            .map(|v| Box::new(v) as Box<dyn RemoteCommit>)
+            .collect())
+    }
+
+    /// Fetches the Gitea API and returns the pull requests.
+    pub async fn get_pull_requests(&self) -> Result<Vec<Box<dyn RemotePullRequest>>> {
+        Ok(self
+            .fetch::<GiteaPullRequest>(0)
+            .await?
+            .into_iter()
+            .map(|v| Box::new(v) as Box<dyn RemotePullRequest>)
+            .collect())
+    }
 }
diff --git a/git-cliff-core/src/remote/github.rs b/git-cliff-core/src/remote/github.rs
index 8a06a706c9..ffd870f683 100644
--- a/git-cliff-core/src/remote/github.rs
+++ b/git-cliff-core/src/remote/github.rs
@@ -1,10 +1,7 @@
 use crate::config::Remote;
 use crate::error::*;
 use reqwest_middleware::ClientWithMiddleware;
-use serde::{
-	Deserialize,
-	Serialize,
-};
+use serde::{Deserialize, Serialize};
 use std::env;
 
 use super::*;
@@ -22,163 +19,160 @@ pub const START_FETCHING_MSG: &str = "Retrieving data from GitHub...";
 pub const FINISHED_FETCHING_MSG: &str = "Done fetching GitHub data.";
 
 /// Template variables related to this remote.
-pub(crate) const TEMPLATE_VARIABLES: &[&str] =
-	&["github", "commit.github", "commit.remote"];
+pub(crate) const TEMPLATE_VARIABLES: &[&str] = &["github", "commit.github", "commit.remote"];
 
 /// Representation of a single commit.
 #[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
 pub struct GitHubCommit {
-	/// SHA.
-	pub sha:    String,
-	/// Author of the commit.
-	pub author: Option<GitHubCommitAuthor>,
+    /// SHA.
+    pub sha: String,
+    /// Author of the commit.
+    pub author: Option<GitHubCommitAuthor>,
 }
 
 impl RemoteCommit for GitHubCommit {
-	fn id(&self) -> String {
-		self.sha.clone()
-	}
+    fn id(&self) -> String {
+        self.sha.clone()
+    }
 
-	fn username(&self) -> Option<String> {
-		self.author.clone().and_then(|v| v.login)
-	}
+    fn username(&self) -> Option<String> {
+        self.author.clone().and_then(|v| v.login)
+    }
 }
 
 impl RemoteEntry for GitHubCommit {
-	fn url(_id: i64, api_url: &str, remote: &Remote, page: i32) -> String {
-		format!(
-			"{}/repos/{}/{}/commits?per_page={MAX_PAGE_SIZE}&page={page}",
-			api_url, remote.owner, remote.repo
-		)
-	}
-	fn buffer_size() -> usize {
-		10
-	}
-
-	fn early_exit(&self) -> bool {
-		false
-	}
+    fn url(_id: i64, api_url: &str, remote: &Remote, page: i32) -> String {
+        format!(
+            "{}/repos/{}/{}/commits?per_page={MAX_PAGE_SIZE}&page={page}",
+            api_url, remote.owner, remote.repo
+        )
+    }
+    fn buffer_size() -> usize {
+        10
+    }
+
+    fn early_exit(&self) -> bool {
+        false
+    }
 }
 
 /// Author of the commit.
 #[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
 pub struct GitHubCommitAuthor {
-	/// Username.
-	pub login: Option<String>,
+    /// Username.
+    pub login: Option<String>,
 }
 
 /// Label of the pull request.
 #[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct PullRequestLabel {
-	/// Name of the label.
-	pub name: String,
+    /// Name of the label.
+    pub name: String,
 }
 
 /// Representation of a single pull request.
 #[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
 pub struct GitHubPullRequest {
-	/// Pull request number.
-	pub number:           i64,
-	/// Pull request title.
-	pub title:            Option<String>,
-	/// SHA of the merge commit.
-	pub merge_commit_sha: Option<String>,
-	/// Labels of the pull request.
-	pub labels:           Vec<PullRequestLabel>,
+    /// Pull request number.
+    pub number: i64,
+    /// Pull request title.
+    pub title: Option<String>,
+    /// SHA of the merge commit.
+    pub merge_commit_sha: Option<String>,
+    /// Labels of the pull request.
+    pub labels: Vec<PullRequestLabel>,
 }
 
 impl RemotePullRequest for GitHubPullRequest {
-	fn number(&self) -> i64 {
-		self.number
-	}
+    fn number(&self) -> i64 {
+        self.number
+    }
 
-	fn title(&self) -> Option<String> {
-		self.title.clone()
-	}
+    fn title(&self) -> Option<String> {
+        self.title.clone()
+    }
 
-	fn labels(&self) -> Vec<String> {
-		self.labels.iter().map(|v| v.name.clone()).collect()
-	}
+    fn labels(&self) -> Vec<String> {
+        self.labels.iter().map(|v| v.name.clone()).collect()
+    }
 
-	fn merge_commit(&self) -> Option<String> {
-		self.merge_commit_sha.clone()
-	}
+    fn merge_commit(&self) -> Option<String> {
+        self.merge_commit_sha.clone()
+    }
 }
 
 impl RemoteEntry for GitHubPullRequest {
-	fn url(_id: i64, api_url: &str, remote: &Remote, page: i32) -> String {
-		format!(
-			"{}/repos/{}/{}/pulls?per_page={MAX_PAGE_SIZE}&page={page}&state=closed",
-			api_url, remote.owner, remote.repo
-		)
-	}
-
-	fn buffer_size() -> usize {
-		5
-	}
-
-	fn early_exit(&self) -> bool {
-		false
-	}
+    fn url(_id: i64, api_url: &str, remote: &Remote, page: i32) -> String {
+        format!(
+            "{}/repos/{}/{}/pulls?per_page={MAX_PAGE_SIZE}&page={page}&state=closed",
+            api_url, remote.owner, remote.repo
+        )
+    }
+
+    fn buffer_size() -> usize {
+        5
+    }
+
+    fn early_exit(&self) -> bool {
+        false
+    }
 }
 
 /// HTTP client for handling GitHub REST API requests.
 #[derive(Debug, Clone)]
 pub struct GitHubClient {
-	/// Remote.
-	remote: Remote,
-	/// HTTP client.
-	client: ClientWithMiddleware,
+    /// Remote.
+    remote: Remote,
+    /// HTTP client.
+    client: ClientWithMiddleware,
 }
 
 /// Constructs a GitHub client from the remote configuration.
 impl TryFrom<Remote> for GitHubClient {
-	type Error = Error;
-	fn try_from(remote: Remote) -> Result<Self> {
-		Ok(Self {
-			client: create_remote_client(&remote, "application/vnd.github+json")?,
-			remote,
-		})
-	}
+    type Error = Error;
+    fn try_from(remote: Remote) -> Result<Self> {
+        Ok(Self {
+            client: create_remote_client(&remote, "application/vnd.github+json")?,
+            remote,
+        })
+    }
 }
 
 impl RemoteClient for GitHubClient {
-	fn api_url() -> String {
-		env::var(GITHUB_API_URL_ENV)
-			.ok()
-			.unwrap_or_else(|| GITHUB_API_URL.to_string())
-	}
-
-	fn remote(&self) -> Remote {
-		self.remote.clone()
-	}
-
-	fn client(&self) -> ClientWithMiddleware {
-		self.client.clone()
-	}
+    fn api_url() -> String {
+        env::var(GITHUB_API_URL_ENV)
+            .ok()
+            .unwrap_or_else(|| GITHUB_API_URL.to_string())
+    }
+
+    fn remote(&self) -> Remote {
+        self.remote.clone()
+    }
+
+    fn client(&self) -> ClientWithMiddleware {
+        self.client.clone()
+    }
 }
 
 impl GitHubClient {
-	/// Fetches the GitHub API and returns the commits.
-	pub async fn get_commits(&self) -> Result<Vec<Box<dyn RemoteCommit>>> {
-		Ok(self
-			.fetch::<GitHubCommit>(0)
-			.await?
-			.into_iter()
-			.map(|v| Box::new(v) as Box<dyn RemoteCommit>)
-			.collect())
-	}
-
-	/// Fetches the GitHub API and returns the pull requests.
-	pub async fn get_pull_requests(
-		&self,
-	) -> Result<Vec<Box<dyn RemotePullRequest>>> {
-		Ok(self
-			.fetch::<GitHubPullRequest>(0)
-			.await?
-			.into_iter()
-			.map(|v| Box::new(v) as Box<dyn RemotePullRequest>)
-			.collect())
-	}
+    /// Fetches the GitHub API and returns the commits.
+    pub async fn get_commits(&self) -> Result<Vec<Box<dyn RemoteCommit>>> {
+        Ok(self
+            .fetch::<GitHubCommit>(0)
+            .await?
+            .into_iter()
+            .map(|v| Box::new(v) as Box<dyn RemoteCommit>)
+            .collect())
+    }
+
+    /// Fetches the GitHub API and returns the pull requests.
+    pub async fn get_pull_requests(&self) -> Result<Vec<Box<dyn RemotePullRequest>>> {
+        Ok(self
+            .fetch::<GitHubPullRequest>(0)
+            .await?
+            .into_iter()
+            .map(|v| Box::new(v) as Box<dyn RemotePullRequest>)
+            .collect())
+    }
 }
diff --git a/git-cliff-core/src/remote/gitlab.rs b/git-cliff-core/src/remote/gitlab.rs
index 52b2d590c9..ddfaf3e1a4 100644
--- a/git-cliff-core/src/remote/gitlab.rs
+++ b/git-cliff-core/src/remote/gitlab.rs
@@ -1,10 +1,7 @@
 use crate::config::Remote;
 use crate::error::*;
 use reqwest_middleware::ClientWithMiddleware;
-use serde::{
-	Deserialize,
-	Serialize,
-};
+use serde::{Deserialize, Serialize};
 use std::env;
 
 use super::*;
@@ -22,47 +19,46 @@ pub const START_FETCHING_MSG: &str = "Retrieving data from GitLab...";
 pub const FINISHED_FETCHING_MSG: &str = "Done fetching GitLab data.";
 
 /// Template variables related to this remote.
-pub(crate) const TEMPLATE_VARIABLES: &[&str] =
-	&["gitlab", "commit.gitlab", "commit.remote"];
+pub(crate) const TEMPLATE_VARIABLES: &[&str] = &["gitlab", "commit.gitlab", "commit.remote"];
 
 /// Representation of a single GitLab Project.
 ///
 /// <https://docs.gitlab.com/ee/api/projects.html#get-single-project>
 #[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
 pub struct GitLabProject {
-	/// GitLab id for project
-	pub id:                  i64,
-	/// Optional Description of project
-	pub description:         Option<String>,
-	/// Name of project
-	pub name:                String,
-	/// Name of project with namespace owner / repo
-	pub name_with_namespace: String,
-	/// Name of project with namespace owner/repo
-	pub path_with_namespace: String,
-	/// Project created at
-	pub created_at:          String,
-	/// Default branch eg (main/master)
-	pub default_branch:      String,
+    /// GitLab id for project
+    pub id: i64,
+    /// Optional Description of project
+    pub description: Option<String>,
+    /// Name of project
+    pub name: String,
+    /// Name of project with namespace owner / repo
+    pub name_with_namespace: String,
+    /// Name of project with namespace owner/repo
+    pub path_with_namespace: String,
+    /// Project created at
+    pub created_at: String,
+    /// Default branch eg (main/master)
+    pub default_branch: String,
 }
 
 impl RemoteEntry for GitLabProject {
-	fn url(_id: i64, api_url: &str, remote: &Remote, _page: i32) -> String {
-		format!(
-			"{}/projects/{}%2F{}",
-			api_url,
-			urlencoding::encode(remote.owner.as_str()),
-			remote.repo
-		)
-	}
-
-	fn buffer_size() -> usize {
-		1
-	}
-
-	fn early_exit(&self) -> bool {
-		false
-	}
+    fn url(_id: i64, api_url: &str, remote: &Remote, _page: i32) -> String {
+        format!(
+            "{}/projects/{}%2F{}",
+            api_url,
+            urlencoding::encode(remote.owner.as_str()),
+            remote.repo
+        )
+    }
+
+    fn buffer_size() -> usize {
+        1
+    }
+
+    fn early_exit(&self) -> bool {
+        false
+    }
 }
 
 /// Representation of a single commit.
@@ -70,60 +66,60 @@ impl RemoteEntry for GitLabProject {
 /// <https://docs.gitlab.com/ee/api/commits.html>
 #[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
 pub struct GitLabCommit {
-	/// Sha
-	pub id:              String,
-	/// Short Sha
-	pub short_id:        String,
-	/// Git message
-	pub title:           String,
-	/// Author
-	pub author_name:     String,
-	/// Author Email
-	pub author_email:    String,
-	/// Authored Date
-	pub authored_date:   String,
-	/// Committer Name
-	pub committer_name:  String,
-	/// Committer Email
-	pub committer_email: String,
-	/// Committed Date
-	pub committed_date:  String,
-	/// Created At
-	pub created_at:      String,
-	/// Git Message
-	pub message:         String,
-	/// Parent Ids
-	pub parent_ids:      Vec<String>,
-	/// Web Url
-	pub web_url:         String,
+    /// Sha
+    pub id: String,
+    /// Short Sha
+    pub short_id: String,
+    /// Git message
+    pub title: String,
+    /// Author
+    pub author_name: String,
+    /// Author Email
+    pub author_email: String,
+    /// Authored Date
+    pub authored_date: String,
+    /// Committer Name
+    pub committer_name: String,
+    /// Committer Email
+    pub committer_email: String,
+    /// Committed Date
+    pub committed_date: String,
+    /// Created At
+    pub created_at: String,
+    /// Git Message
+    pub message: String,
+    /// Parent Ids
+    pub parent_ids: Vec<String>,
+    /// Web Url
+    pub web_url: String,
 }
 
 impl RemoteCommit for GitLabCommit {
-	fn id(&self) -> String {
-		self.id.clone()
-	}
+    fn id(&self) -> String {
+        self.id.clone()
+    }
 
-	fn username(&self) -> Option<String> {
-		Some(self.author_name.clone())
-	}
+    fn username(&self) -> Option<String> {
+        Some(self.author_name.clone())
+    }
 }
 
 impl RemoteEntry for GitLabCommit {
-	fn url(id: i64, api_url: &str, _remote: &Remote, page: i32) -> String {
-		let commit_page = page + 1;
-		format!(
-			"{}/projects/{}/repository/commits?per_page={MAX_PAGE_SIZE}&\
+    fn url(id: i64, api_url: &str, _remote: &Remote, page: i32) -> String {
+        let commit_page = page + 1;
+        format!(
+            "{}/projects/{}/repository/commits?per_page={MAX_PAGE_SIZE}&\
 			 page={commit_page}",
-			api_url, id
-		)
-	}
-	fn buffer_size() -> usize {
-		10
-	}
-
-	fn early_exit(&self) -> bool {
-		false
-	}
+            api_url, id
+        )
+    }
+    fn buffer_size() -> usize {
+        10
+    }
+
+    fn early_exit(&self) -> bool {
+        false
+    }
 }
 
 /// Representation of a single pull request.
@@ -131,177 +127,174 @@ impl RemoteEntry for GitLabCommit {
 /// <https://docs.gitlab.com/ee/api/merge_requests.html>
 #[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
 pub struct GitLabMergeRequest {
-	/// Id
-	pub id:                i64,
-	/// Iid
-	pub iid:               i64,
-	/// Project Id
-	pub project_id:        i64,
-	/// Title
-	pub title:             String,
-	/// Description
-	pub description:       String,
-	/// State
-	pub state:             String,
-	/// Created At
-	pub created_at:        String,
-	/// Author
-	pub author:            GitLabUser,
-	/// Commit Sha
-	pub sha:               String,
-	/// Merge Commit Sha
-	pub merge_commit_sha:  Option<String>,
-	/// Squash Commit Sha
-	pub squash_commit_sha: Option<String>,
-	/// Web Url
-	pub web_url:           String,
-	/// Labels
-	pub labels:            Vec<String>,
+    /// Id
+    pub id: i64,
+    /// Iid
+    pub iid: i64,
+    /// Project Id
+    pub project_id: i64,
+    /// Title
+    pub title: String,
+    /// Description
+    pub description: String,
+    /// State
+    pub state: String,
+    /// Created At
+    pub created_at: String,
+    /// Author
+    pub author: GitLabUser,
+    /// Commit Sha
+    pub sha: String,
+    /// Merge Commit Sha
+    pub merge_commit_sha: Option<String>,
+    /// Squash Commit Sha
+    pub squash_commit_sha: Option<String>,
+    /// Web Url
+    pub web_url: String,
+    /// Labels
+    pub labels: Vec<String>,
 }
 
 impl RemotePullRequest for GitLabMergeRequest {
-	fn number(&self) -> i64 {
-		self.iid
-	}
+    fn number(&self) -> i64 {
+        self.iid
+    }
 
-	fn title(&self) -> Option<String> {
-		Some(self.title.clone())
-	}
+    fn title(&self) -> Option<String> {
+        Some(self.title.clone())
+    }
 
-	fn labels(&self) -> Vec<String> {
-		self.labels.clone()
-	}
+    fn labels(&self) -> Vec<String> {
+        self.labels.clone()
+    }
 
-	fn merge_commit(&self) -> Option<String> {
-		self.merge_commit_sha.clone()
-	}
+    fn merge_commit(&self) -> Option<String> {
+        self.merge_commit_sha.clone()
+    }
 }
 
 impl RemoteEntry for GitLabMergeRequest {
-	fn url(id: i64, api_url: &str, _remote: &Remote, page: i32) -> String {
-		format!(
-			"{}/projects/{}/merge_requests?per_page={MAX_PAGE_SIZE}&page={page}&\
+    fn url(id: i64, api_url: &str, _remote: &Remote, page: i32) -> String {
+        format!(
+            "{}/projects/{}/merge_requests?per_page={MAX_PAGE_SIZE}&page={page}&\
 			 state=merged",
-			api_url, id
-		)
-	}
+            api_url, id
+        )
+    }
 
-	fn buffer_size() -> usize {
-		5
-	}
+    fn buffer_size() -> usize {
+        5
+    }
 
-	fn early_exit(&self) -> bool {
-		false
-	}
+    fn early_exit(&self) -> bool {
+        false
+    }
 }
 
 /// Representation of a GitLab User.
 #[derive(Debug, Default, Clone, Hash, Eq, PartialEq, Deserialize, Serialize)]
 pub struct GitLabUser {
-	/// Id
-	pub id:         i64,
-	/// Name
-	pub name:       String,
-	/// Username
-	pub username:   String,
-	/// State of the User
-	pub state:      String,
-	/// Url for avatar
-	pub avatar_url: Option<String>,
-	/// Web Url
-	pub web_url:    String,
+    /// Id
+    pub id: i64,
+    /// Name
+    pub name: String,
+    /// Username
+    pub username: String,
+    /// State of the User
+    pub state: String,
+    /// Url for avatar
+    pub avatar_url: Option<String>,
+    /// Web Url
+    pub web_url: String,
 }
 
 /// Representation of a GitLab Reference.
 #[derive(Debug, Default, Clone, Hash, Eq, PartialEq, Deserialize, Serialize)]
 pub struct GitLabReference {
-	/// Short id
-	pub short:    String,
-	/// Relative Link
-	pub relative: String,
-	/// Full Link
-	pub full:     String,
+    /// Short id
+    pub short: String,
+    /// Relative Link
+    pub relative: String,
+    /// Full Link
+    pub full: String,
 }
 
 /// HTTP client for handling GitLab REST API requests.
 #[derive(Debug, Clone)]
 pub struct GitLabClient {
-	/// Remote.
-	remote: Remote,
-	/// HTTP client.
-	client: ClientWithMiddleware,
+    /// Remote.
+    remote: Remote,
+    /// HTTP client.
+    client: ClientWithMiddleware,
 }
 
 /// Constructs a GitLab client from the remote configuration.
 impl TryFrom<Remote> for GitLabClient {
-	type Error = Error;
-	fn try_from(remote: Remote) -> Result<Self> {
-		Ok(Self {
-			client: create_remote_client(&remote, "application/json")?,
-			remote,
-		})
-	}
+    type Error = Error;
+    fn try_from(remote: Remote) -> Result<Self> {
+        Ok(Self {
+            client: create_remote_client(&remote, "application/json")?,
+            remote,
+        })
+    }
 }
 
 impl RemoteClient for GitLabClient {
-	fn api_url() -> String {
-		env::var(GITLAB_API_URL_ENV)
-			.ok()
-			.unwrap_or_else(|| GITLAB_API_URL.to_string())
-	}
-
-	fn remote(&self) -> Remote {
-		self.remote.clone()
-	}
-
-	fn client(&self) -> ClientWithMiddleware {
-		self.client.clone()
-	}
+    fn api_url() -> String {
+        env::var(GITLAB_API_URL_ENV)
+            .ok()
+            .unwrap_or_else(|| GITLAB_API_URL.to_string())
+    }
+
+    fn remote(&self) -> Remote {
+        self.remote.clone()
+    }
+
+    fn client(&self) -> ClientWithMiddleware {
+        self.client.clone()
+    }
 }
 
 impl GitLabClient {
-	/// Fetches the GitLab API and returns the pull requests.
-	pub async fn get_project(&self) -> Result<GitLabProject> {
-		self.get_entry::<GitLabProject>(0, 1).await
-	}
-
-	/// Fetches the GitLab API and returns the commits.
-	pub async fn get_commits(
-		&self,
-		project_id: i64,
-	) -> Result<Vec<Box<dyn RemoteCommit>>> {
-		Ok(self
-			.fetch::<GitLabCommit>(project_id)
-			.await?
-			.into_iter()
-			.map(|v| Box::new(v) as Box<dyn RemoteCommit>)
-			.collect())
-	}
-
-	/// Fetches the GitLab API and returns the pull requests.
-	pub async fn get_merge_requests(
-		&self,
-		project_id: i64,
-	) -> Result<Vec<Box<dyn RemotePullRequest>>> {
-		Ok(self
-			.fetch::<GitLabMergeRequest>(project_id)
-			.await?
-			.into_iter()
-			.map(|v| Box::new(v) as Box<dyn RemotePullRequest>)
-			.collect())
-	}
+    /// Fetches the GitLab API and returns the pull requests.
+    pub async fn get_project(&self) -> Result<GitLabProject> {
+        self.get_entry::<GitLabProject>(0, 1).await
+    }
+
+    /// Fetches the GitLab API and returns the commits.
+    pub async fn get_commits(&self, project_id: i64) -> Result<Vec<Box<dyn RemoteCommit>>> {
+        Ok(self
+            .fetch::<GitLabCommit>(project_id)
+            .await?
+            .into_iter()
+            .map(|v| Box::new(v) as Box<dyn RemoteCommit>)
+            .collect())
+    }
+
+    /// Fetches the GitLab API and returns the pull requests.
+    pub async fn get_merge_requests(
+        &self,
+        project_id: i64,
+    ) -> Result<Vec<Box<dyn RemotePullRequest>>> {
+        Ok(self
+            .fetch::<GitLabMergeRequest>(project_id)
+            .await?
+            .into_iter()
+            .map(|v| Box::new(v) as Box<dyn RemotePullRequest>)
+            .collect())
+    }
 }
 #[cfg(test)]
 mod test {
-	use super::*;
-	use pretty_assertions::assert_eq;
-
-	#[test]
-	fn gitlab_remote_encodes_owner() {
-		let remote = Remote::new("abc/def", "xyz1");
-		assert_eq!(
-			"https://gitlab.test.com/api/v4/projects/abc%2Fdef%2Fxyz1",
-			GitLabProject::url(1, "https://gitlab.test.com/api/v4", &remote, 0)
-		);
-	}
+    use super::*;
+    use pretty_assertions::assert_eq;
+
+    #[test]
+    fn gitlab_remote_encodes_owner() {
+        let remote = Remote::new("abc/def", "xyz1");
+        assert_eq!(
+            "https://gitlab.test.com/api/v4/projects/abc%2Fdef%2Fxyz1",
+            GitLabProject::url(1, "https://gitlab.test.com/api/v4", &remote, 0)
+        );
+    }
 }
diff --git a/git-cliff-core/src/remote/mod.rs b/git-cliff-core/src/remote/mod.rs
index 77d14e72b5..05c39d613d 100644
--- a/git-cliff-core/src/remote/mod.rs
+++ b/git-cliff-core/src/remote/mod.rs
@@ -16,38 +16,16 @@ pub mod gitea;
 
 use crate::config::Remote;
 use crate::contributor::RemoteContributor;
-use crate::error::{
-	Error,
-	Result,
-};
+use crate::error::{Error, Result};
 use dyn_clone::DynClone;
-use futures::{
-	future,
-	stream,
-	StreamExt,
-};
-use http_cache_reqwest::{
-	CACacheManager,
-	Cache,
-	CacheMode,
-	HttpCache,
-	HttpCacheOptions,
-};
-use reqwest::header::{
-	HeaderMap,
-	HeaderValue,
-};
+use futures::{future, stream, StreamExt};
+use http_cache_reqwest::{CACacheManager, Cache, CacheMode, HttpCache, HttpCacheOptions};
+use reqwest::header::{HeaderMap, HeaderValue};
 use reqwest::Client;
-use reqwest_middleware::{
-	ClientBuilder,
-	ClientWithMiddleware,
-};
+use reqwest_middleware::{ClientBuilder, ClientWithMiddleware};
 use secrecy::ExposeSecret;
 use serde::de::DeserializeOwned;
-use serde::{
-	Deserialize,
-	Serialize,
-};
+use serde::{Deserialize, Serialize};
 use std::fmt::Debug;
 use std::hash::Hash;
 use std::time::Duration;
@@ -55,8 +33,7 @@ use std::time::Duration;
 /// User agent for interacting with the GitHub API.
 ///
 /// This is needed since GitHub API does not accept empty user agent.
-pub(crate) const USER_AGENT: &str =
-	concat!(env!("CARGO_PKG_NAME"), env!("CARGO_PKG_VERSION"));
+pub(crate) const USER_AGENT: &str = concat!(env!("CARGO_PKG_NAME"), env!("CARGO_PKG_VERSION"));
 
 /// Request timeout value in seconds.
 pub(crate) const REQUEST_TIMEOUT: u64 = 30;
@@ -69,284 +46,272 @@ pub(crate) const MAX_PAGE_SIZE: usize = 100;
 
 /// Trait for handling the different entries returned from the remote.
 pub trait RemoteEntry {
-	/// Returns the API URL for fetching the entries at the specified page.
-	fn url(project_id: i64, api_url: &str, remote: &Remote, page: i32) -> String;
-	/// Returns the request buffer size.
-	fn buffer_size() -> usize;
-	/// Whether if exit early.
-	fn early_exit(&self) -> bool;
+    /// Returns the API URL for fetching the entries at the specified page.
+    fn url(project_id: i64, api_url: &str, remote: &Remote, page: i32) -> String;
+    /// Returns the request buffer size.
+    fn buffer_size() -> usize;
+    /// Whether if exit early.
+    fn early_exit(&self) -> bool;
 }
 
 /// Trait for handling remote commits.
 pub trait RemoteCommit: DynClone {
-	/// Commit SHA.
-	fn id(&self) -> String;
-	/// Commit author.
-	fn username(&self) -> Option<String>;
+    /// Commit SHA.
+    fn id(&self) -> String;
+    /// Commit author.
+    fn username(&self) -> Option<String>;
 }
 
 dyn_clone::clone_trait_object!(RemoteCommit);
 
 /// Trait for handling remote pull requests.
 pub trait RemotePullRequest: DynClone {
-	/// Number.
-	fn number(&self) -> i64;
-	/// Title.
-	fn title(&self) -> Option<String>;
-	/// Labels of the pull request.
-	fn labels(&self) -> Vec<String>;
-	/// Merge commit SHA.
-	fn merge_commit(&self) -> Option<String>;
+    /// Number.
+    fn number(&self) -> i64;
+    /// Title.
+    fn title(&self) -> Option<String>;
+    /// Labels of the pull request.
+    fn labels(&self) -> Vec<String>;
+    /// Merge commit SHA.
+    fn merge_commit(&self) -> Option<String>;
 }
 
 dyn_clone::clone_trait_object!(RemotePullRequest);
 
 /// Result of a remote metadata.
-pub type RemoteMetadata =
-	(Vec<Box<dyn RemoteCommit>>, Vec<Box<dyn RemotePullRequest>>);
+pub type RemoteMetadata = (Vec<Box<dyn RemoteCommit>>, Vec<Box<dyn RemotePullRequest>>);
 
 /// Metadata of a remote release.
 #[derive(Debug, Default, Clone, Eq, PartialEq, Deserialize, Serialize)]
 pub struct RemoteReleaseMetadata {
-	/// Contributors.
-	pub contributors: Vec<RemoteContributor>,
+    /// Contributors.
+    pub contributors: Vec<RemoteContributor>,
 }
 
 /// Creates a HTTP client for the remote.
-fn create_remote_client(
-	remote: &Remote,
-	accept_header: &str,
-) -> Result<ClientWithMiddleware> {
-	if !remote.is_set() {
-		return Err(Error::RemoteNotSetError);
-	}
-	let mut headers = HeaderMap::new();
-	headers.insert(
-		reqwest::header::ACCEPT,
-		HeaderValue::from_str(accept_header)?,
-	);
-	if let Some(token) = &remote.token {
-		headers.insert(
-			reqwest::header::AUTHORIZATION,
-			format!("Bearer {}", token.expose_secret()).parse()?,
-		);
-	}
-	headers.insert(reqwest::header::USER_AGENT, USER_AGENT.parse()?);
-	let client = Client::builder()
-		.timeout(Duration::from_secs(REQUEST_TIMEOUT))
-		.tcp_keepalive(Duration::from_secs(REQUEST_KEEP_ALIVE))
-		.default_headers(headers)
-		.build()?;
-	let client = ClientBuilder::new(client)
-		.with(Cache(HttpCache {
-			mode:    CacheMode::Default,
-			manager: CACacheManager {
-				path: dirs::cache_dir()
-					.ok_or_else(|| {
-						Error::DirsError(String::from(
-							"failed to find the user's cache directory",
-						))
-					})?
-					.join(env!("CARGO_PKG_NAME")),
-			},
-			options: HttpCacheOptions::default(),
-		}))
-		.build();
-	Ok(client)
+fn create_remote_client(remote: &Remote, accept_header: &str) -> Result<ClientWithMiddleware> {
+    if !remote.is_set() {
+        return Err(Error::RemoteNotSetError);
+    }
+    let mut headers = HeaderMap::new();
+    headers.insert(
+        reqwest::header::ACCEPT,
+        HeaderValue::from_str(accept_header)?,
+    );
+    if let Some(token) = &remote.token {
+        headers.insert(
+            reqwest::header::AUTHORIZATION,
+            format!("Bearer {}", token.expose_secret()).parse()?,
+        );
+    }
+    headers.insert(reqwest::header::USER_AGENT, USER_AGENT.parse()?);
+    let client = Client::builder()
+        .timeout(Duration::from_secs(REQUEST_TIMEOUT))
+        .tcp_keepalive(Duration::from_secs(REQUEST_KEEP_ALIVE))
+        .default_headers(headers)
+        .build()?;
+    let client = ClientBuilder::new(client)
+        .with(Cache(HttpCache {
+            mode: CacheMode::Default,
+            manager: CACacheManager {
+                path: dirs::cache_dir()
+                    .ok_or_else(|| {
+                        Error::DirsError(String::from("failed to find the user's cache directory"))
+                    })?
+                    .join(env!("CARGO_PKG_NAME")),
+            },
+            options: HttpCacheOptions::default(),
+        }))
+        .build();
+    Ok(client)
 }
 
 /// Trait for handling the API connection and fetching.
 pub trait RemoteClient {
-	/// Returns the API url.
-	fn api_url() -> String;
+    /// Returns the API url.
+    fn api_url() -> String;
 
-	/// Returns the remote repository information.
-	fn remote(&self) -> Remote;
+    /// Returns the remote repository information.
+    fn remote(&self) -> Remote;
 
-	/// Returns the HTTP client for making requests.
-	fn client(&self) -> ClientWithMiddleware;
+    /// Returns the HTTP client for making requests.
+    fn client(&self) -> ClientWithMiddleware;
 
-	/// Returns true if the client should early exit.
-	fn early_exit<T: DeserializeOwned + RemoteEntry>(&self, page: &T) -> bool {
-		page.early_exit()
-	}
+    /// Returns true if the client should early exit.
+    fn early_exit<T: DeserializeOwned + RemoteEntry>(&self, page: &T) -> bool {
+        page.early_exit()
+    }
 
-	/// Retrieves a single object.
-	async fn get_entry<T: DeserializeOwned + RemoteEntry>(
-		&self,
-		project_id: i64,
-		page: i32,
-	) -> Result<T> {
-		let url = T::url(project_id, &Self::api_url(), &self.remote(), page);
-		debug!("Sending request to: {url}");
-		let response = self.client().get(&url).send().await?;
-		let response_text = if response.status().is_success() {
-			let text = response.text().await?;
-			trace!("Response: {:?}", text);
-			text
-		} else {
-			let text = response.text().await?;
-			error!("Request error: {}", text);
-			text
-		};
-		Ok(serde_json::from_str::<T>(&response_text)?)
-	}
+    /// Retrieves a single object.
+    async fn get_entry<T: DeserializeOwned + RemoteEntry>(
+        &self,
+        project_id: i64,
+        page: i32,
+    ) -> Result<T> {
+        let url = T::url(project_id, &Self::api_url(), &self.remote(), page);
+        debug!("Sending request to: {url}");
+        let response = self.client().get(&url).send().await?;
+        let response_text = if response.status().is_success() {
+            let text = response.text().await?;
+            trace!("Response: {:?}", text);
+            text
+        } else {
+            let text = response.text().await?;
+            error!("Request error: {}", text);
+            text
+        };
+        Ok(serde_json::from_str::<T>(&response_text)?)
+    }
 
-	/// Retrieves a single page of entries.
-	async fn get_entries_with_page<T: DeserializeOwned + RemoteEntry>(
-		&self,
-		project_id: i64,
-		page: i32,
-	) -> Result<Vec<T>> {
-		let url = T::url(project_id, &Self::api_url(), &self.remote(), page);
-		debug!("Sending request to: {url}");
-		let response = self.client().get(&url).send().await?;
-		let response_text = if response.status().is_success() {
-			let text = response.text().await?;
-			trace!("Response: {:?}", text);
-			text
-		} else {
-			let text = response.text().await?;
-			error!("Request error: {}", text);
-			text
-		};
-		let response = serde_json::from_str::<Vec<T>>(&response_text)?;
-		if response.is_empty() {
-			Err(Error::PaginationError(String::from("end of entries")))
-		} else {
-			Ok(response)
-		}
-	}
+    /// Retrieves a single page of entries.
+    async fn get_entries_with_page<T: DeserializeOwned + RemoteEntry>(
+        &self,
+        project_id: i64,
+        page: i32,
+    ) -> Result<Vec<T>> {
+        let url = T::url(project_id, &Self::api_url(), &self.remote(), page);
+        debug!("Sending request to: {url}");
+        let response = self.client().get(&url).send().await?;
+        let response_text = if response.status().is_success() {
+            let text = response.text().await?;
+            trace!("Response: {:?}", text);
+            text
+        } else {
+            let text = response.text().await?;
+            error!("Request error: {}", text);
+            text
+        };
+        let response = serde_json::from_str::<Vec<T>>(&response_text)?;
+        if response.is_empty() {
+            Err(Error::PaginationError(String::from("end of entries")))
+        } else {
+            Ok(response)
+        }
+    }
 
-	/// Fetches the remote API and returns the given entry.
-	///
-	/// See `fetch_with_early_exit` for the early exit version of this method.
-	async fn fetch<T: DeserializeOwned + RemoteEntry>(
-		&self,
-		project_id: i64,
-	) -> Result<Vec<T>> {
-		let entries: Vec<Vec<T>> = stream::iter(0..)
-			.map(|i| self.get_entries_with_page(project_id, i))
-			.buffered(T::buffer_size())
-			.take_while(|page| {
-				if let Err(e) = page {
-					debug!("Error while fetching page: {:?}", e);
-				}
-				future::ready(page.is_ok())
-			})
-			.map(|page| match page {
-				Ok(v) => v,
-				Err(ref e) => {
-					log::error!("{:#?}", e);
-					page.expect("failed to fetch page: {}")
-				}
-			})
-			.collect()
-			.await;
-		Ok(entries.into_iter().flatten().collect())
-	}
+    /// Fetches the remote API and returns the given entry.
+    ///
+    /// See `fetch_with_early_exit` for the early exit version of this method.
+    async fn fetch<T: DeserializeOwned + RemoteEntry>(&self, project_id: i64) -> Result<Vec<T>> {
+        let entries: Vec<Vec<T>> = stream::iter(0..)
+            .map(|i| self.get_entries_with_page(project_id, i))
+            .buffered(T::buffer_size())
+            .take_while(|page| {
+                if let Err(e) = page {
+                    debug!("Error while fetching page: {:?}", e);
+                }
+                future::ready(page.is_ok())
+            })
+            .map(|page| match page {
+                Ok(v) => v,
+                Err(ref e) => {
+                    log::error!("{:#?}", e);
+                    page.expect("failed to fetch page: {}")
+                }
+            })
+            .collect()
+            .await;
+        Ok(entries.into_iter().flatten().collect())
+    }
 
-	/// Fetches the remote API and returns the given entry.
-	///
-	/// Early exits based on the response.
-	async fn fetch_with_early_exit<T: DeserializeOwned + RemoteEntry>(
-		&self,
-		project_id: i64,
-	) -> Result<Vec<T>> {
-		let entries: Vec<T> = stream::iter(0..)
-			.map(|i| self.get_entry::<T>(project_id, i))
-			.buffered(T::buffer_size())
-			.take_while(|page| {
-				let status = match page {
-					Ok(v) => !self.early_exit(v),
-					Err(e) => {
-						debug!("Error while fetching page: {:?}", e);
-						true
-					}
-				};
-				future::ready(status && page.is_ok())
-			})
-			.map(|page| match page {
-				Ok(v) => v,
-				Err(ref e) => {
-					log::error!("{:#?}", e);
-					page.expect("failed to fetch page: {}")
-				}
-			})
-			.collect()
-			.await;
-		Ok(entries)
-	}
+    /// Fetches the remote API and returns the given entry.
+    ///
+    /// Early exits based on the response.
+    async fn fetch_with_early_exit<T: DeserializeOwned + RemoteEntry>(
+        &self,
+        project_id: i64,
+    ) -> Result<Vec<T>> {
+        let entries: Vec<T> = stream::iter(0..)
+            .map(|i| self.get_entry::<T>(project_id, i))
+            .buffered(T::buffer_size())
+            .take_while(|page| {
+                let status = match page {
+                    Ok(v) => !self.early_exit(v),
+                    Err(e) => {
+                        debug!("Error while fetching page: {:?}", e);
+                        true
+                    }
+                };
+                future::ready(status && page.is_ok())
+            })
+            .map(|page| match page {
+                Ok(v) => v,
+                Err(ref e) => {
+                    log::error!("{:#?}", e);
+                    page.expect("failed to fetch page: {}")
+                }
+            })
+            .collect()
+            .await;
+        Ok(entries)
+    }
 }
 
 /// Generates a function for updating the release metadata for a remote.
 #[doc(hidden)]
 #[macro_export]
 macro_rules! update_release_metadata {
-	($remote: ident, $fn: ident) => {
-		impl<'a> Release<'a> {
-			/// Updates the remote metadata that is contained in the release.
-			///
-			/// This function takes two arguments:
-			///
-			/// - Commits: needed for associating the Git user with the GitHub
-			///   username.
-			/// - Pull requests: needed for generating the contributor list for the
-			///   release.
-			#[allow(deprecated)]
-			pub fn $fn(
-				&mut self,
-				mut commits: Vec<Box<dyn RemoteCommit>>,
-				pull_requests: Vec<Box<dyn RemotePullRequest>>,
-			) -> Result<()> {
-				let mut contributors: Vec<RemoteContributor> = Vec::new();
-				// retain the commits that are not a part of this release for later
-				// on checking the first contributors.
-				commits.retain(|v| {
-					if let Some(commit) =
-						self.commits.iter_mut().find(|commit| commit.id == v.id())
-					{
-						let pull_request = pull_requests
-							.iter()
-							.find(|pr| pr.merge_commit() == Some(v.id().clone()));
-						commit.$remote.username = v.username();
-						commit.$remote.pr_number = pull_request.map(|v| v.number());
-						commit.$remote.pr_title =
-							pull_request.and_then(|v| v.title().clone());
-						commit.$remote.pr_labels = pull_request
-							.map(|v| v.labels().clone())
-							.unwrap_or_default();
-						if !contributors
-							.iter()
-							.any(|v| commit.$remote.username == v.username)
-						{
-							contributors.push(RemoteContributor {
-								username:      commit.$remote.username.clone(),
-								pr_title:      commit.$remote.pr_title.clone(),
-								pr_number:     commit.$remote.pr_number,
-								pr_labels:     commit.$remote.pr_labels.clone(),
-								is_first_time: false,
-							});
-						}
-						commit.remote = Some(commit.$remote.clone());
-						false
-					} else {
-						true
-					}
-				});
-				// mark contributors as first-time
-				self.$remote.contributors = contributors
-					.into_iter()
-					.map(|mut v| {
-						v.is_first_time = !commits
-							.iter()
-							.map(|v| v.username())
-							.any(|login| login == v.username);
-						v
-					})
-					.collect();
-				Ok(())
-			}
-		}
-	};
+    ($remote: ident, $fn: ident) => {
+        impl<'a> Release<'a> {
+            /// Updates the remote metadata that is contained in the release.
+            ///
+            /// This function takes two arguments:
+            ///
+            /// - Commits: needed for associating the Git user with the GitHub
+            ///   username.
+            /// - Pull requests: needed for generating the contributor list for the
+            ///   release.
+            #[allow(deprecated)]
+            pub fn $fn(
+                &mut self,
+                mut commits: Vec<Box<dyn RemoteCommit>>,
+                pull_requests: Vec<Box<dyn RemotePullRequest>>,
+            ) -> Result<()> {
+                let mut contributors: Vec<RemoteContributor> = Vec::new();
+                // retain the commits that are not a part of this release for later
+                // on checking the first contributors.
+                commits.retain(|v| {
+                    if let Some(commit) = self.commits.iter_mut().find(|commit| commit.id == v.id())
+                    {
+                        let pull_request = pull_requests
+                            .iter()
+                            .find(|pr| pr.merge_commit() == Some(v.id().clone()));
+                        commit.$remote.username = v.username();
+                        commit.$remote.pr_number = pull_request.map(|v| v.number());
+                        commit.$remote.pr_title = pull_request.and_then(|v| v.title().clone());
+                        commit.$remote.pr_labels =
+                            pull_request.map(|v| v.labels().clone()).unwrap_or_default();
+                        if !contributors
+                            .iter()
+                            .any(|v| commit.$remote.username == v.username)
+                        {
+                            contributors.push(RemoteContributor {
+                                username: commit.$remote.username.clone(),
+                                pr_title: commit.$remote.pr_title.clone(),
+                                pr_number: commit.$remote.pr_number,
+                                pr_labels: commit.$remote.pr_labels.clone(),
+                                is_first_time: false,
+                            });
+                        }
+                        commit.remote = Some(commit.$remote.clone());
+                        false
+                    } else {
+                        true
+                    }
+                });
+                // mark contributors as first-time
+                self.$remote.contributors = contributors
+                    .into_iter()
+                    .map(|mut v| {
+                        v.is_first_time = !commits
+                            .iter()
+                            .map(|v| v.username())
+                            .any(|login| login == v.username);
+                        v
+                    })
+                    .collect();
+                Ok(())
+            }
+        }
+    };
 }
diff --git a/git-cliff-core/src/repo.rs b/git-cliff-core/src/repo.rs
index 8fe1f08731..9c304fe24b 100644
--- a/git-cliff-core/src/repo.rs
+++ b/git-cliff-core/src/repo.rs
@@ -1,33 +1,20 @@
 use crate::config::Remote;
-use crate::error::{
-	Error,
-	Result,
-};
+use crate::error::{Error, Result};
 use crate::tag::Tag;
 use git2::{
-	BranchType,
-	Commit,
-	DescribeOptions,
-	Oid,
-	Repository as GitRepository,
-	Sort,
-	TreeWalkMode,
+    BranchType, Commit, DescribeOptions, Oid, Repository as GitRepository, Sort, TreeWalkMode,
 };
 use glob::Pattern;
 use indexmap::IndexMap;
-use lazy_regex::{
-	lazy_regex,
-	Lazy,
-	Regex,
-};
+use lazy_regex::{lazy_regex, Lazy, Regex};
 use std::io;
 use std::path::PathBuf;
 use url::Url;
 
 /// Regex for replacing the signature part of a tag message.
 static TAG_SIGNATURE_REGEX: Lazy<Regex> = lazy_regex!(
-	// https://git-scm.com/docs/gitformat-signature#_description
-	r"(?s)-----BEGIN (PGP|SSH|SIGNED) (SIGNATURE|MESSAGE)-----(.*?)-----END (PGP|SSH|SIGNED) (SIGNATURE|MESSAGE)-----"
+    // https://git-scm.com/docs/gitformat-signature#_description
+    r"(?s)-----BEGIN (PGP|SSH|SIGNED) (SIGNATURE|MESSAGE)-----(.*?)-----END (PGP|SSH|SIGNED) (SIGNATURE|MESSAGE)-----"
 );
 
 /// Name of the cache file for changed files.
@@ -37,743 +24,682 @@ const CHANGED_FILES_CACHE: &str = "changed_files_cache";
 ///
 /// [`Repository`]: GitRepository
 pub struct Repository {
-	inner:                    GitRepository,
-	/// Repository path.
-	pub path:                 PathBuf,
-	/// Cache path for the changed files of the commits.
-	changed_files_cache_path: PathBuf,
+    inner: GitRepository,
+    /// Repository path.
+    pub path: PathBuf,
+    /// Cache path for the changed files of the commits.
+    changed_files_cache_path: PathBuf,
 }
 
 impl Repository {
-	/// Initializes (opens) the repository.
-	pub fn init(path: PathBuf) -> Result<Self> {
-		if path.exists() {
-			let inner = GitRepository::open(&path)?;
-			let changed_files_cache_path = inner
-				.path()
-				.join(env!("CARGO_PKG_NAME"))
-				.join(CHANGED_FILES_CACHE);
-			Ok(Self {
-				inner,
-				path,
-				changed_files_cache_path,
-			})
-		} else {
-			Err(Error::IoError(io::Error::new(
-				io::ErrorKind::NotFound,
-				"repository path not found",
-			)))
-		}
-	}
-
-	/// Parses and returns the commits.
-	///
-	/// Sorts the commits by their time.
-	pub fn commits(
-		&self,
-		range: Option<&str>,
-		include_path: Option<Vec<Pattern>>,
-		exclude_path: Option<Vec<Pattern>>,
-	) -> Result<Vec<Commit>> {
-		let mut revwalk = self.inner.revwalk()?;
-		revwalk.set_sorting(Sort::TOPOLOGICAL)?;
-		if let Some(range) = range {
-			revwalk.push_range(range)?;
-		} else {
-			revwalk.push_head()?;
-		}
-		let mut commits: Vec<Commit> = revwalk
-			.filter_map(|id| id.ok())
-			.filter_map(|id| self.inner.find_commit(id).ok())
-			.collect();
-		if include_path.is_some() || exclude_path.is_some() {
-			let include_patterns = include_path.map(|patterns| {
-				patterns.into_iter().map(Self::normalize_pattern).collect()
-			});
-			let exclude_patterns = exclude_path.map(|patterns| {
-				patterns.into_iter().map(Self::normalize_pattern).collect()
-			});
-			commits.retain(|commit| {
-				self.should_retain_commit(
-					commit,
-					&include_patterns,
-					&exclude_patterns,
-				)
-			});
-		}
-		Ok(commits)
-	}
-
-	/// Normalizes the glob pattern to match the git diff paths.
-	///
-	/// It removes the leading `./` and adds `**` to the end if the pattern is a
-	/// directory.
-	fn normalize_pattern(pattern: Pattern) -> Pattern {
-		let star_added = match pattern.as_str().chars().last() {
-			Some('/' | '\\') => Pattern::new(&format!("{pattern}**"))
-				.expect("failed to add '**' to the end of glob"),
-			_ => pattern,
-		};
-		let pattern_normal = match star_added.as_str().strip_prefix("./") {
-			Some(stripped) => Pattern::new(stripped)
-				.expect("failed to remove leading ./ from glob"),
-			None => star_added,
-		};
-		pattern_normal
-	}
-
-	/// Calculates whether the commit should be retained or not.
-	///
-	/// This function is used to filter the commits based on the changed files,
-	/// and include/exclude patterns.
-	fn should_retain_commit(
-		&self,
-		commit: &Commit,
-		include_patterns: &Option<Vec<Pattern>>,
-		exclude_patterns: &Option<Vec<Pattern>>,
-	) -> bool {
-		let changed_files = self.commit_changed_files(commit);
-		match (include_patterns, exclude_patterns) {
-			(Some(include_pattern), Some(exclude_pattern)) => {
-				// check if the commit has any changed files that match any of the
-				// include patterns and non of the exclude patterns.
-				changed_files.iter().any(|path| {
-					include_pattern
-						.iter()
-						.any(|pattern| pattern.matches_path(path)) &&
-						!exclude_pattern
-							.iter()
-							.any(|pattern| pattern.matches_path(path))
-				})
-			}
-			(Some(include_pattern), None) => {
-				// check if the commit has any changed files that match the include
-				// patterns.
-				changed_files.iter().any(|path| {
-					include_pattern
-						.iter()
-						.any(|pattern| pattern.matches_path(path))
-				})
-			}
-			(None, Some(exclude_pattern)) => {
-				// check if the commit has at least one changed file that does not
-				// match all exclude patterns.
-				changed_files.iter().any(|path| {
-					!exclude_pattern
-						.iter()
-						.any(|pattern| pattern.matches_path(path))
-				})
-			}
-			(None, None) => true,
-		}
-	}
-
-	/// Returns the changed files of the commit.
-	///
-	/// It uses a cache to speed up checks to store the changed files of the
-	/// commits under `./.git/git-cliff-core/changed_files_cache`. The speed-up
-	/// was measured to be around 260x for large repositories.
-	///
-	/// If the cache is not found, it calculates the changed files and adds them
-	/// to the cache via [`Self::commit_changed_files_no_cache`].
-	fn commit_changed_files(&self, commit: &Commit) -> Vec<PathBuf> {
-		// Cache key is generated from the repository path and commit id
-		let cache_key = format!("commit_id:{}", commit.id());
-
-		// Check the cache first.
-		{
-			if let Ok(result) =
-				cacache::read_sync(&self.changed_files_cache_path, &cache_key)
-			{
-				if let Ok((files, _)) =
-					bincode::decode_from_slice(&result, bincode::config::standard())
-				{
-					return files;
-				}
-			}
-		}
-
-		// If the cache is not found, calculate the result and set it to the cache.
-		let result = self.commit_changed_files_no_cache(commit);
-		match bincode::encode_to_vec(
-			self.commit_changed_files_no_cache(commit),
-			bincode::config::standard(),
-		) {
-			Ok(v) => {
-				if let Err(e) = cacache::write_sync_with_algo(
-					cacache::Algorithm::Xxh3,
-					&self.changed_files_cache_path,
-					cache_key,
-					v,
-				) {
-					error!("Failed to set cache for repo {:?}: {e}", self.path);
-				}
-			}
-			Err(e) => {
-				error!("Failed to serialize cache for repo {:?}: {e}", self.path);
-			}
-		}
-
-		result
-	}
-
-	/// Calculate the changed files of the commit.
-	///
-	/// This function does not use the cache (directly calls git2).
-	fn commit_changed_files_no_cache(&self, commit: &Commit) -> Vec<PathBuf> {
-		let mut changed_files = Vec::new();
-		if let Ok(prev_commit) = commit.parent(0) {
-			// Compare the current commit with the previous commit to get the
-			// changed files.
-			// libgit2 does not provide a way to get the changed files directly, so
-			// the full diff is calculated here.
-			if let Ok(diff) = self.inner.diff_tree_to_tree(
-				commit.tree().ok().as_ref(),
-				prev_commit.tree().ok().as_ref(),
-				None,
-			) {
-				changed_files.extend(
-					diff.deltas().filter_map(|delta| {
-						delta.new_file().path().map(PathBuf::from)
-					}),
-				);
-			}
-		} else {
-			// If there is no parent, it is the first commit.
-			// So get all the files in the tree.
-			if let Ok(tree) = commit.tree() {
-				tree.walk(TreeWalkMode::PreOrder, |dir, entry| {
-					if entry.kind().expect("failed to get entry kind") !=
-						git2::ObjectType::Blob
-					{
-						return 0;
-					}
-					let name = entry.name().expect("failed to get entry name");
-					let entry_path = if dir == "," {
-						name.to_string()
-					} else {
-						format!("{dir}/{name}")
-					};
-					changed_files.push(entry_path.into());
-					0
-				})
-				.expect("failed to get the changed files of the first commit");
-			}
-		}
-		changed_files
-	}
-
-	/// Returns the current tag.
-	///
-	/// It is the same as running `git describe --tags`
-	pub fn current_tag(&self) -> Option<Tag> {
-		self.inner
-			.describe(DescribeOptions::new().describe_tags())
-			.ok()
-			.and_then(|describe| {
-				describe
-					.format(None)
-					.ok()
-					.map(|name| self.resolve_tag(&name))
-			})
-	}
-
-	/// Returns the tag object of the given name.
-	///
-	/// If given name doesn't exist, it still returns `Tag` with the given name.
-	pub fn resolve_tag(&self, name: &str) -> Tag {
-		match self
-			.inner
-			.resolve_reference_from_short_name(name)
-			.and_then(|r| r.peel_to_tag())
-		{
-			Ok(tag) => Tag {
-				name:    tag.name().unwrap_or_default().to_owned(),
-				message: tag.message().map(|msg| {
-					TAG_SIGNATURE_REGEX.replace(msg, "").trim().to_owned()
-				}),
-			},
-			_ => Tag {
-				name:    name.to_owned(),
-				message: None,
-			},
-		}
-	}
-
-	/// Returns the commit object of the given ID.
-	pub fn find_commit(&self, id: &str) -> Option<Commit> {
-		if let Ok(oid) = Oid::from_str(id) {
-			if let Ok(commit) = self.inner.find_commit(oid) {
-				return Some(commit);
-			}
-		}
-		None
-	}
-
-	/// Decide whether to include tag.
-	///
-	/// `head_commit` is the `latest` commit to generate changelog. It can be a
-	/// branch head or a detached head. `tag_commit` is a tagged commit. If the
-	/// commit is in the descendant graph of the `head_commit` or is the
-	/// `head_commit` itself, Changelog should include the tag.
-	fn should_include_tag(
-		&self,
-		head_commit: &Commit,
-		tag_commit: &Commit,
-	) -> Result<bool> {
-		Ok(self
-			.inner
-			.graph_descendant_of(head_commit.id(), tag_commit.id())? ||
-			head_commit.id() == tag_commit.id())
-	}
-
-	/// Parses and returns a commit-tag map.
-	///
-	/// It collects lightweight and annotated tags.
-	pub fn tags(
-		&self,
-		pattern: &Option<Regex>,
-		topo_order: bool,
-		use_branch_tags: bool,
-	) -> Result<IndexMap<String, Tag>> {
-		let mut tags: Vec<(Commit, Tag)> = Vec::new();
-		let tag_names = self.inner.tag_names(None)?;
-		let head_commit = self.inner.head()?.peel_to_commit()?;
-		for name in tag_names
-			.iter()
-			.flatten()
-			.filter(|tag_name| {
-				pattern.as_ref().map_or(true, |pat| pat.is_match(tag_name))
-			})
-			.map(String::from)
-		{
-			let obj = self.inner.revparse_single(&name)?;
-			if let Ok(commit) = obj.clone().into_commit() {
-				if use_branch_tags &&
-					!self.should_include_tag(&head_commit, &commit)?
-				{
-					continue;
-				}
-
-				tags.push((commit, Tag {
-					name,
-					message: None,
-				}));
-			} else if let Some(tag) = obj.as_tag() {
-				if let Some(commit) = tag
-					.target()
-					.ok()
-					.and_then(|target| target.into_commit().ok())
-				{
-					if use_branch_tags &&
-						!self.should_include_tag(&head_commit, &commit)?
-					{
-						continue;
-					}
-					tags.push((commit, Tag {
-						name:    tag.name().map(String::from).unwrap_or(name),
-						message: tag.message().map(|msg| {
-							TAG_SIGNATURE_REGEX.replace(msg, "").trim().to_owned()
-						}),
-					}));
-				}
-			}
-		}
-		if !topo_order {
-			tags.sort_by(|a, b| a.0.time().seconds().cmp(&b.0.time().seconds()));
-		}
-		Ok(tags
-			.into_iter()
-			.map(|(a, b)| (a.id().to_string(), b))
-			.collect())
-	}
-
-	/// Returns the remote of the upstream repository.
-	///
-	/// The strategy used here is the following:
-	///
-	/// Find the branch that HEAD points to, and read the remote configured for
-	/// that branch returns the remote and the name of the local branch.
-	pub fn upstream_remote(&self) -> Result<Remote> {
-		for branch in self.inner.branches(Some(BranchType::Local))? {
-			let branch = branch?.0;
-			if branch.is_head() {
-				let upstream = &self.inner.branch_upstream_remote(&format!(
-					"refs/heads/{}",
-					&branch.name()?.ok_or_else(|| Error::RepoError(
-						String::from("branch name is not valid")
-					))?
-				))?;
-				let upstream_name = upstream.as_str().ok_or_else(|| {
-					Error::RepoError(String::from(
-						"name of the upstream remote is not valid",
-					))
-				})?;
-				let origin = &self.inner.find_remote(upstream_name)?;
-				let url = origin
-					.url()
-					.ok_or_else(|| {
-						Error::RepoError(String::from(
-							"failed to get the remote URL",
-						))
-					})?
-					.to_string();
-				trace!("Upstream URL: {url}");
-				let url = Url::parse(&url)?;
-				let segments: Vec<&str> = url
-					.path_segments()
-					.ok_or_else(|| {
-						Error::RepoError(String::from("failed to get URL segments"))
-					})?
-					.rev()
-					.collect();
-				if let (Some(owner), Some(repo)) =
-					(segments.get(1), segments.first())
-				{
-					return Ok(Remote {
-						owner:     owner.to_string(),
-						repo:      repo.trim_end_matches(".git").to_string(),
-						token:     None,
-						is_custom: false,
-					});
-				}
-			}
-		}
-		Err(Error::RepoError(String::from("no remotes configured")))
-	}
+    /// Initializes (opens) the repository.
+    pub fn init(path: PathBuf) -> Result<Self> {
+        if path.exists() {
+            let inner = GitRepository::open(&path)?;
+            let changed_files_cache_path = inner
+                .path()
+                .join(env!("CARGO_PKG_NAME"))
+                .join(CHANGED_FILES_CACHE);
+            Ok(Self {
+                inner,
+                path,
+                changed_files_cache_path,
+            })
+        } else {
+            Err(Error::IoError(io::Error::new(
+                io::ErrorKind::NotFound,
+                "repository path not found",
+            )))
+        }
+    }
+
+    /// Parses and returns the commits.
+    ///
+    /// Sorts the commits by their time.
+    pub fn commits(
+        &self,
+        range: Option<&str>,
+        include_path: Option<Vec<Pattern>>,
+        exclude_path: Option<Vec<Pattern>>,
+    ) -> Result<Vec<Commit>> {
+        let mut revwalk = self.inner.revwalk()?;
+        revwalk.set_sorting(Sort::TOPOLOGICAL)?;
+        if let Some(range) = range {
+            revwalk.push_range(range)?;
+        } else {
+            revwalk.push_head()?;
+        }
+        let mut commits: Vec<Commit> = revwalk
+            .filter_map(|id| id.ok())
+            .filter_map(|id| self.inner.find_commit(id).ok())
+            .collect();
+        if include_path.is_some() || exclude_path.is_some() {
+            let include_patterns = include_path
+                .map(|patterns| patterns.into_iter().map(Self::normalize_pattern).collect());
+            let exclude_patterns = exclude_path
+                .map(|patterns| patterns.into_iter().map(Self::normalize_pattern).collect());
+            commits.retain(|commit| {
+                self.should_retain_commit(commit, &include_patterns, &exclude_patterns)
+            });
+        }
+        Ok(commits)
+    }
+
+    /// Normalizes the glob pattern to match the git diff paths.
+    ///
+    /// It removes the leading `./` and adds `**` to the end if the pattern is a
+    /// directory.
+    fn normalize_pattern(pattern: Pattern) -> Pattern {
+        let star_added = match pattern.as_str().chars().last() {
+            Some('/' | '\\') => Pattern::new(&format!("{pattern}**"))
+                .expect("failed to add '**' to the end of glob"),
+            _ => pattern,
+        };
+        let pattern_normal = match star_added.as_str().strip_prefix("./") {
+            Some(stripped) => {
+                Pattern::new(stripped).expect("failed to remove leading ./ from glob")
+            }
+            None => star_added,
+        };
+        pattern_normal
+    }
+
+    /// Calculates whether the commit should be retained or not.
+    ///
+    /// This function is used to filter the commits based on the changed files,
+    /// and include/exclude patterns.
+    fn should_retain_commit(
+        &self,
+        commit: &Commit,
+        include_patterns: &Option<Vec<Pattern>>,
+        exclude_patterns: &Option<Vec<Pattern>>,
+    ) -> bool {
+        let changed_files = self.commit_changed_files(commit);
+        match (include_patterns, exclude_patterns) {
+            (Some(include_pattern), Some(exclude_pattern)) => {
+                // check if the commit has any changed files that match any of the
+                // include patterns and non of the exclude patterns.
+                changed_files.iter().any(|path| {
+                    include_pattern
+                        .iter()
+                        .any(|pattern| pattern.matches_path(path))
+                        && !exclude_pattern
+                            .iter()
+                            .any(|pattern| pattern.matches_path(path))
+                })
+            }
+            (Some(include_pattern), None) => {
+                // check if the commit has any changed files that match the include
+                // patterns.
+                changed_files.iter().any(|path| {
+                    include_pattern
+                        .iter()
+                        .any(|pattern| pattern.matches_path(path))
+                })
+            }
+            (None, Some(exclude_pattern)) => {
+                // check if the commit has at least one changed file that does not
+                // match all exclude patterns.
+                changed_files.iter().any(|path| {
+                    !exclude_pattern
+                        .iter()
+                        .any(|pattern| pattern.matches_path(path))
+                })
+            }
+            (None, None) => true,
+        }
+    }
+
+    /// Returns the changed files of the commit.
+    ///
+    /// It uses a cache to speed up checks to store the changed files of the
+    /// commits under `./.git/git-cliff-core/changed_files_cache`. The speed-up
+    /// was measured to be around 260x for large repositories.
+    ///
+    /// If the cache is not found, it calculates the changed files and adds them
+    /// to the cache via [`Self::commit_changed_files_no_cache`].
+    fn commit_changed_files(&self, commit: &Commit) -> Vec<PathBuf> {
+        // Cache key is generated from the repository path and commit id
+        let cache_key = format!("commit_id:{}", commit.id());
+
+        // Check the cache first.
+        {
+            if let Ok(result) = cacache::read_sync(&self.changed_files_cache_path, &cache_key) {
+                if let Ok((files, _)) =
+                    bincode::decode_from_slice(&result, bincode::config::standard())
+                {
+                    return files;
+                }
+            }
+        }
+
+        // If the cache is not found, calculate the result and set it to the cache.
+        let result = self.commit_changed_files_no_cache(commit);
+        match bincode::encode_to_vec(
+            self.commit_changed_files_no_cache(commit),
+            bincode::config::standard(),
+        ) {
+            Ok(v) => {
+                if let Err(e) = cacache::write_sync_with_algo(
+                    cacache::Algorithm::Xxh3,
+                    &self.changed_files_cache_path,
+                    cache_key,
+                    v,
+                ) {
+                    error!("Failed to set cache for repo {:?}: {e}", self.path);
+                }
+            }
+            Err(e) => {
+                error!("Failed to serialize cache for repo {:?}: {e}", self.path);
+            }
+        }
+
+        result
+    }
+
+    /// Calculate the changed files of the commit.
+    ///
+    /// This function does not use the cache (directly calls git2).
+    fn commit_changed_files_no_cache(&self, commit: &Commit) -> Vec<PathBuf> {
+        let mut changed_files = Vec::new();
+        if let Ok(prev_commit) = commit.parent(0) {
+            // Compare the current commit with the previous commit to get the
+            // changed files.
+            // libgit2 does not provide a way to get the changed files directly, so
+            // the full diff is calculated here.
+            if let Ok(diff) = self.inner.diff_tree_to_tree(
+                commit.tree().ok().as_ref(),
+                prev_commit.tree().ok().as_ref(),
+                None,
+            ) {
+                changed_files.extend(
+                    diff.deltas()
+                        .filter_map(|delta| delta.new_file().path().map(PathBuf::from)),
+                );
+            }
+        } else {
+            // If there is no parent, it is the first commit.
+            // So get all the files in the tree.
+            if let Ok(tree) = commit.tree() {
+                tree.walk(TreeWalkMode::PreOrder, |dir, entry| {
+                    if entry.kind().expect("failed to get entry kind") != git2::ObjectType::Blob {
+                        return 0;
+                    }
+                    let name = entry.name().expect("failed to get entry name");
+                    let entry_path = if dir == "," {
+                        name.to_string()
+                    } else {
+                        format!("{dir}/{name}")
+                    };
+                    changed_files.push(entry_path.into());
+                    0
+                })
+                .expect("failed to get the changed files of the first commit");
+            }
+        }
+        changed_files
+    }
+
+    /// Returns the current tag.
+    ///
+    /// It is the same as running `git describe --tags`
+    pub fn current_tag(&self) -> Option<Tag> {
+        self.inner
+            .describe(DescribeOptions::new().describe_tags())
+            .ok()
+            .and_then(|describe| {
+                describe
+                    .format(None)
+                    .ok()
+                    .map(|name| self.resolve_tag(&name))
+            })
+    }
+
+    /// Returns the tag object of the given name.
+    ///
+    /// If given name doesn't exist, it still returns `Tag` with the given name.
+    pub fn resolve_tag(&self, name: &str) -> Tag {
+        match self
+            .inner
+            .resolve_reference_from_short_name(name)
+            .and_then(|r| r.peel_to_tag())
+        {
+            Ok(tag) => Tag {
+                name: tag.name().unwrap_or_default().to_owned(),
+                message: tag
+                    .message()
+                    .map(|msg| TAG_SIGNATURE_REGEX.replace(msg, "").trim().to_owned()),
+            },
+            _ => Tag {
+                name: name.to_owned(),
+                message: None,
+            },
+        }
+    }
+
+    /// Returns the commit object of the given ID.
+    pub fn find_commit(&self, id: &str) -> Option<Commit> {
+        if let Ok(oid) = Oid::from_str(id) {
+            if let Ok(commit) = self.inner.find_commit(oid) {
+                return Some(commit);
+            }
+        }
+        None
+    }
+
+    /// Decide whether to include tag.
+    ///
+    /// `head_commit` is the `latest` commit to generate changelog. It can be a
+    /// branch head or a detached head. `tag_commit` is a tagged commit. If the
+    /// commit is in the descendant graph of the `head_commit` or is the
+    /// `head_commit` itself, Changelog should include the tag.
+    fn should_include_tag(&self, head_commit: &Commit, tag_commit: &Commit) -> Result<bool> {
+        Ok(self
+            .inner
+            .graph_descendant_of(head_commit.id(), tag_commit.id())?
+            || head_commit.id() == tag_commit.id())
+    }
+
+    /// Parses and returns a commit-tag map.
+    ///
+    /// It collects lightweight and annotated tags.
+    pub fn tags(
+        &self,
+        pattern: &Option<Regex>,
+        topo_order: bool,
+        use_branch_tags: bool,
+    ) -> Result<IndexMap<String, Tag>> {
+        let mut tags: Vec<(Commit, Tag)> = Vec::new();
+        let tag_names = self.inner.tag_names(None)?;
+        let head_commit = self.inner.head()?.peel_to_commit()?;
+        for name in tag_names
+            .iter()
+            .flatten()
+            .filter(|tag_name| pattern.as_ref().map_or(true, |pat| pat.is_match(tag_name)))
+            .map(String::from)
+        {
+            let obj = self.inner.revparse_single(&name)?;
+            if let Ok(commit) = obj.clone().into_commit() {
+                if use_branch_tags && !self.should_include_tag(&head_commit, &commit)? {
+                    continue;
+                }
+
+                tags.push((
+                    commit,
+                    Tag {
+                        name,
+                        message: None,
+                    },
+                ));
+            } else if let Some(tag) = obj.as_tag() {
+                if let Some(commit) = tag
+                    .target()
+                    .ok()
+                    .and_then(|target| target.into_commit().ok())
+                {
+                    if use_branch_tags && !self.should_include_tag(&head_commit, &commit)? {
+                        continue;
+                    }
+                    tags.push((
+                        commit,
+                        Tag {
+                            name: tag.name().map(String::from).unwrap_or(name),
+                            message: tag
+                                .message()
+                                .map(|msg| TAG_SIGNATURE_REGEX.replace(msg, "").trim().to_owned()),
+                        },
+                    ));
+                }
+            }
+        }
+        if !topo_order {
+            tags.sort_by(|a, b| a.0.time().seconds().cmp(&b.0.time().seconds()));
+        }
+        Ok(tags
+            .into_iter()
+            .map(|(a, b)| (a.id().to_string(), b))
+            .collect())
+    }
+
+    /// Returns the remote of the upstream repository.
+    ///
+    /// The strategy used here is the following:
+    ///
+    /// Find the branch that HEAD points to, and read the remote configured for
+    /// that branch returns the remote and the name of the local branch.
+    pub fn upstream_remote(&self) -> Result<Remote> {
+        for branch in self.inner.branches(Some(BranchType::Local))? {
+            let branch = branch?.0;
+            if branch.is_head() {
+                let upstream = &self.inner.branch_upstream_remote(&format!(
+                    "refs/heads/{}",
+                    &branch.name()?.ok_or_else(|| Error::RepoError(String::from(
+                        "branch name is not valid"
+                    )))?
+                ))?;
+                let upstream_name = upstream.as_str().ok_or_else(|| {
+                    Error::RepoError(String::from("name of the upstream remote is not valid"))
+                })?;
+                let origin = &self.inner.find_remote(upstream_name)?;
+                let url = origin
+                    .url()
+                    .ok_or_else(|| Error::RepoError(String::from("failed to get the remote URL")))?
+                    .to_string();
+                trace!("Upstream URL: {url}");
+                let url = Url::parse(&url)?;
+                let segments: Vec<&str> = url
+                    .path_segments()
+                    .ok_or_else(|| Error::RepoError(String::from("failed to get URL segments")))?
+                    .rev()
+                    .collect();
+                if let (Some(owner), Some(repo)) = (segments.get(1), segments.first()) {
+                    return Ok(Remote {
+                        owner: owner.to_string(),
+                        repo: repo.trim_end_matches(".git").to_string(),
+                        token: None,
+                        is_custom: false,
+                    });
+                }
+            }
+        }
+        Err(Error::RepoError(String::from("no remotes configured")))
+    }
 }
 
 #[cfg(test)]
 mod test {
-	use super::*;
-	use crate::commit::Commit as AppCommit;
-	use std::env;
-	use std::process::Command;
-	use std::str;
-	use temp_dir::TempDir;
-
-	fn get_last_commit_hash() -> Result<String> {
-		Ok(str::from_utf8(
-			Command::new("git")
-				.args(["log", "--pretty=format:'%H'", "-n", "1"])
-				.output()?
-				.stdout
-				.as_ref(),
-		)?
-		.trim_matches('\'')
-		.to_string())
-	}
-
-	fn get_last_tag() -> Result<String> {
-		Ok(str::from_utf8(
-			Command::new("git")
-				.args(["describe", "--abbrev=0"])
-				.output()?
-				.stdout
-				.as_ref(),
-		)?
-		.trim()
-		.to_string())
-	}
-
-	fn get_repository() -> Result<Repository> {
-		Repository::init(
-			PathBuf::from(env!("CARGO_MANIFEST_DIR"))
-				.parent()
-				.expect("parent directory not found")
-				.to_path_buf(),
-		)
-	}
-
-	#[test]
-	fn get_latest_commit() -> Result<()> {
-		let repository = get_repository()?;
-		let commits = repository.commits(None, None, None)?;
-		let last_commit =
-			AppCommit::from(&commits.first().expect("no commits found").clone());
-		assert_eq!(get_last_commit_hash()?, last_commit.id);
-		Ok(())
-	}
-
-	#[test]
-	fn get_latest_tag() -> Result<()> {
-		let repository = get_repository()?;
-		let tags = repository.tags(&None, false, false)?;
-		assert_eq!(get_last_tag()?, tags.last().expect("no tags found").1.name);
-		Ok(())
-	}
-
-	#[test]
-	fn git_tags() -> Result<()> {
-		let repository = get_repository()?;
-		let tags = repository.tags(&None, true, false)?;
-		assert_eq!(
-			tags.get("2b8b4d3535f29231e05c3572e919634b9af907b6")
-				.expect(
-					"the commit hash does not exist in the repository (tag v0.1.0)"
-				)
-				.name,
-			"v0.1.0"
-		);
-		assert_eq!(
-			tags.get("4ddef08debfff48117586296e49d5caa0800d1b5")
-				.expect(
-					"the commit hash does not exist in the repository (tag \
+    use super::*;
+    use crate::commit::Commit as AppCommit;
+    use std::env;
+    use std::process::Command;
+    use std::str;
+    use temp_dir::TempDir;
+
+    fn get_last_commit_hash() -> Result<String> {
+        Ok(str::from_utf8(
+            Command::new("git")
+                .args(["log", "--pretty=format:'%H'", "-n", "1"])
+                .output()?
+                .stdout
+                .as_ref(),
+        )?
+        .trim_matches('\'')
+        .to_string())
+    }
+
+    fn get_last_tag() -> Result<String> {
+        Ok(str::from_utf8(
+            Command::new("git")
+                .args(["describe", "--abbrev=0"])
+                .output()?
+                .stdout
+                .as_ref(),
+        )?
+        .trim()
+        .to_string())
+    }
+
+    fn get_repository() -> Result<Repository> {
+        Repository::init(
+            PathBuf::from(env!("CARGO_MANIFEST_DIR"))
+                .parent()
+                .expect("parent directory not found")
+                .to_path_buf(),
+        )
+    }
+
+    #[test]
+    fn get_latest_commit() -> Result<()> {
+        let repository = get_repository()?;
+        let commits = repository.commits(None, None, None)?;
+        let last_commit = AppCommit::from(&commits.first().expect("no commits found").clone());
+        assert_eq!(get_last_commit_hash()?, last_commit.id);
+        Ok(())
+    }
+
+    #[test]
+    fn get_latest_tag() -> Result<()> {
+        let repository = get_repository()?;
+        let tags = repository.tags(&None, false, false)?;
+        assert_eq!(get_last_tag()?, tags.last().expect("no tags found").1.name);
+        Ok(())
+    }
+
+    #[test]
+    fn git_tags() -> Result<()> {
+        let repository = get_repository()?;
+        let tags = repository.tags(&None, true, false)?;
+        assert_eq!(
+            tags.get("2b8b4d3535f29231e05c3572e919634b9af907b6")
+                .expect("the commit hash does not exist in the repository (tag v0.1.0)")
+                .name,
+            "v0.1.0"
+        );
+        assert_eq!(
+            tags.get("4ddef08debfff48117586296e49d5caa0800d1b5")
+                .expect(
+                    "the commit hash does not exist in the repository (tag \
 					 v0.1.0-beta.4)"
-				)
-				.name,
-			"v0.1.0-beta.4"
-		);
-		let tags = repository.tags(
-			&Some(
-				Regex::new("^v[0-9]+\\.[0-9]+\\.[0-9]$")
-					.expect("the regex is not valid"),
-			),
-			true,
-			false,
-		)?;
-		assert_eq!(
-			tags.get("2b8b4d3535f29231e05c3572e919634b9af907b6")
-				.expect(
-					"the commit hash does not exist in the repository (tag v0.1.0)"
-				)
-				.name,
-			"v0.1.0"
-		);
-		assert!(!tags.contains_key("4ddef08debfff48117586296e49d5caa0800d1b5"));
-		Ok(())
-	}
-
-	#[test]
-	fn git_upstream_remote() -> Result<()> {
-		let repository = get_repository()?;
-		let remote = repository.upstream_remote()?;
-		assert_eq!(
-			Remote {
-				owner:     remote.owner.clone(),
-				repo:      String::from("git-cliff"),
-				token:     None,
-				is_custom: false,
-			},
-			remote
-		);
-		Ok(())
-	}
-
-	#[test]
-	fn resolves_existing_tag_with_name_and_message() -> Result<()> {
-		let repository = get_repository()?;
-		let tag = repository.resolve_tag("v0.2.3");
-		assert_eq!(tag.name, "v0.2.3");
-		assert_eq!(
-			tag.message,
-			Some(
-				"Release v0.2.3\n\nBug Fixes\n- Fetch the dependencies before \
+                )
+                .name,
+            "v0.1.0-beta.4"
+        );
+        let tags = repository.tags(
+            &Some(Regex::new("^v[0-9]+\\.[0-9]+\\.[0-9]$").expect("the regex is not valid")),
+            true,
+            false,
+        )?;
+        assert_eq!(
+            tags.get("2b8b4d3535f29231e05c3572e919634b9af907b6")
+                .expect("the commit hash does not exist in the repository (tag v0.1.0)")
+                .name,
+            "v0.1.0"
+        );
+        assert!(!tags.contains_key("4ddef08debfff48117586296e49d5caa0800d1b5"));
+        Ok(())
+    }
+
+    #[test]
+    fn git_upstream_remote() -> Result<()> {
+        let repository = get_repository()?;
+        let remote = repository.upstream_remote()?;
+        assert_eq!(
+            Remote {
+                owner: remote.owner.clone(),
+                repo: String::from("git-cliff"),
+                token: None,
+                is_custom: false,
+            },
+            remote
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn resolves_existing_tag_with_name_and_message() -> Result<()> {
+        let repository = get_repository()?;
+        let tag = repository.resolve_tag("v0.2.3");
+        assert_eq!(tag.name, "v0.2.3");
+        assert_eq!(
+            tag.message,
+            Some(
+                "Release v0.2.3\n\nBug Fixes\n- Fetch the dependencies before \
 				 copying the file to embed (9e29c95)"
-					.to_string()
-			)
-		);
-
-		Ok(())
-	}
-
-	#[test]
-	fn resolves_tag_when_no_tags_exist() -> Result<()> {
-		let repository = get_repository()?;
-		let tag = repository.resolve_tag("nonexistent-tag");
-		assert_eq!(tag.name, "nonexistent-tag");
-		assert_eq!(tag.message, None);
-		Ok(())
-	}
-
-	fn create_temp_repo() -> (Repository, TempDir) {
-		let temp_dir =
-			TempDir::with_prefix("git-cliff-").expect("failed to create temp dir");
-
-		let output = Command::new("git")
-			.args(["init"])
-			.current_dir(temp_dir.path())
-			.output()
-			.expect("failed to execute git init");
-		assert!(output.status.success(), "git init failed {:?}", output);
-
-		let repo = Repository::init(temp_dir.path().to_path_buf())
-			.expect("failed to init repo");
-		let output = Command::new("git")
-			.args(["config", "user.email", "test@gmail.com"])
-			.current_dir(temp_dir.path())
-			.output()
-			.expect("failed to execute git config user.email");
-		assert!(
-			output.status.success(),
-			"git config user.email failed {:?}",
-			output
-		);
-
-		let output = Command::new("git")
-			.args(["config", "user.name", "test"])
-			.current_dir(temp_dir.path())
-			.output()
-			.expect("failed to execute git config user.name");
-		assert!(
-			output.status.success(),
-			"git config user.name failed {:?}",
-			output
-		);
-
-		(repo, temp_dir)
-	}
-
-	fn create_commit_with_files<'a>(
-		repo: &'a Repository,
-		files: Vec<(&'a str, &'a str)>,
-	) -> Commit<'a> {
-		for (path, content) in files {
-			if let Some(parent) = repo.path.join(path).parent() {
-				std::fs::create_dir_all(parent).expect("failed to create dir");
-			}
-			std::fs::write(repo.path.join(path), content)
-				.expect("failed to write file");
-		}
-
-		let output = Command::new("git")
-			.args(["add", "."])
-			.current_dir(&repo.path)
-			.output()
-			.expect("failed to execute git add");
-		assert!(output.status.success(), "git add failed {:?}", output);
-
-		let output = Command::new("git")
-			.args(["commit", "--no-gpg-sign", "-m", "test commit"])
-			.current_dir(&repo.path)
-			.output()
-			.expect("failed to execute git commit");
-		assert!(output.status.success(), "git commit failed {:?}", output);
-
-		let last_commit = repo
-			.inner
-			.head()
-			.and_then(|head| head.peel_to_commit())
-			.expect("failed to get the last commit");
-
-		last_commit
-	}
-
-	#[test]
-	fn test_should_retain_commit() {
-		let (repo, _temp_dir) = create_temp_repo();
-
-		let new_pattern = |input: &str| {
-			Repository::normalize_pattern(
-				Pattern::new(input).expect("valid pattern"),
-			)
-		};
-
-		let first_commit = create_commit_with_files(&repo, vec![
-			("initial.txt", "initial content"),
-			("dir/initial.txt", "initial content"),
-		]);
-
-		{
-			let retain = repo.should_retain_commit(
-				&first_commit,
-				&Some(vec![new_pattern("dir/")]),
-				&None,
-			);
-			assert!(retain, "include: dir/");
-		}
-
-		let commit = create_commit_with_files(&repo, vec![
-			("file1.txt", "content1"),
-			("file2.txt", "content2"),
-			("dir/file3.txt", "content3"),
-			("dir/subdir/file4.txt", "content4"),
-		]);
-
-		{
-			let retain = repo.should_retain_commit(&commit, &None, &None);
-			assert!(retain, "no include/exclude patterns");
-		}
-
-		{
-			let retain = repo.should_retain_commit(
-				&commit,
-				&Some(vec![new_pattern("./")]),
-				&None,
-			);
-			assert!(retain, "include: ./");
-		}
-
-		{
-			let retain = repo.should_retain_commit(
-				&commit,
-				&Some(vec![new_pattern("**")]),
-				&None,
-			);
-			assert!(retain, "include: **");
-		}
-
-		{
-			let retain = repo.should_retain_commit(
-				&commit,
-				&Some(vec![new_pattern("*")]),
-				&None,
-			);
-			assert!(retain, "include: *");
-		}
-
-		{
-			let retain = repo.should_retain_commit(
-				&commit,
-				&Some(vec![new_pattern("dir/")]),
-				&None,
-			);
-			assert!(retain, "include: dir/");
-		}
-
-		{
-			let retain = repo.should_retain_commit(
-				&commit,
-				&Some(vec![new_pattern("dir/*")]),
-				&None,
-			);
-			assert!(retain, "include: dir/*");
-		}
-
-		{
-			let retain = repo.should_retain_commit(
-				&commit,
-				&Some(vec![new_pattern("file1.txt")]),
-				&None,
-			);
-			assert!(retain, "include: file1.txt");
-		}
-
-		{
-			let retain = repo.should_retain_commit(
-				&commit,
-				&None,
-				&Some(vec![new_pattern("file1.txt")]),
-			);
-			assert!(retain, "exclude: file1.txt");
-		}
-
-		{
-			let retain = repo.should_retain_commit(
-				&commit,
-				&Some(vec![new_pattern("file1.txt")]),
-				&Some(vec![new_pattern("file2.txt")]),
-			);
-			assert!(retain, "include: file1.txt, exclude: file2.txt");
-		}
-
-		{
-			let retain = repo.should_retain_commit(
-				&commit,
-				&None,
-				&Some(vec![new_pattern("**/*.txt")]),
-			);
-			assert!(!retain, "exclude: **/*.txt");
-		}
-	}
+                    .to_string()
+            )
+        );
+
+        Ok(())
+    }
+
+    #[test]
+    fn resolves_tag_when_no_tags_exist() -> Result<()> {
+        let repository = get_repository()?;
+        let tag = repository.resolve_tag("nonexistent-tag");
+        assert_eq!(tag.name, "nonexistent-tag");
+        assert_eq!(tag.message, None);
+        Ok(())
+    }
+
+    fn create_temp_repo() -> (Repository, TempDir) {
+        let temp_dir = TempDir::with_prefix("git-cliff-").expect("failed to create temp dir");
+
+        let output = Command::new("git")
+            .args(["init"])
+            .current_dir(temp_dir.path())
+            .output()
+            .expect("failed to execute git init");
+        assert!(output.status.success(), "git init failed {:?}", output);
+
+        let repo = Repository::init(temp_dir.path().to_path_buf()).expect("failed to init repo");
+        let output = Command::new("git")
+            .args(["config", "user.email", "test@gmail.com"])
+            .current_dir(temp_dir.path())
+            .output()
+            .expect("failed to execute git config user.email");
+        assert!(
+            output.status.success(),
+            "git config user.email failed {:?}",
+            output
+        );
+
+        let output = Command::new("git")
+            .args(["config", "user.name", "test"])
+            .current_dir(temp_dir.path())
+            .output()
+            .expect("failed to execute git config user.name");
+        assert!(
+            output.status.success(),
+            "git config user.name failed {:?}",
+            output
+        );
+
+        (repo, temp_dir)
+    }
+
+    fn create_commit_with_files<'a>(
+        repo: &'a Repository,
+        files: Vec<(&'a str, &'a str)>,
+    ) -> Commit<'a> {
+        for (path, content) in files {
+            if let Some(parent) = repo.path.join(path).parent() {
+                std::fs::create_dir_all(parent).expect("failed to create dir");
+            }
+            std::fs::write(repo.path.join(path), content).expect("failed to write file");
+        }
+
+        let output = Command::new("git")
+            .args(["add", "."])
+            .current_dir(&repo.path)
+            .output()
+            .expect("failed to execute git add");
+        assert!(output.status.success(), "git add failed {:?}", output);
+
+        let output = Command::new("git")
+            .args(["commit", "--no-gpg-sign", "-m", "test commit"])
+            .current_dir(&repo.path)
+            .output()
+            .expect("failed to execute git commit");
+        assert!(output.status.success(), "git commit failed {:?}", output);
+
+        let last_commit = repo
+            .inner
+            .head()
+            .and_then(|head| head.peel_to_commit())
+            .expect("failed to get the last commit");
+
+        last_commit
+    }
+
+    #[test]
+    fn test_should_retain_commit() {
+        let (repo, _temp_dir) = create_temp_repo();
+
+        let new_pattern = |input: &str| {
+            Repository::normalize_pattern(Pattern::new(input).expect("valid pattern"))
+        };
+
+        let first_commit = create_commit_with_files(
+            &repo,
+            vec![
+                ("initial.txt", "initial content"),
+                ("dir/initial.txt", "initial content"),
+            ],
+        );
+
+        {
+            let retain =
+                repo.should_retain_commit(&first_commit, &Some(vec![new_pattern("dir/")]), &None);
+            assert!(retain, "include: dir/");
+        }
+
+        let commit = create_commit_with_files(
+            &repo,
+            vec![
+                ("file1.txt", "content1"),
+                ("file2.txt", "content2"),
+                ("dir/file3.txt", "content3"),
+                ("dir/subdir/file4.txt", "content4"),
+            ],
+        );
+
+        {
+            let retain = repo.should_retain_commit(&commit, &None, &None);
+            assert!(retain, "no include/exclude patterns");
+        }
+
+        {
+            let retain = repo.should_retain_commit(&commit, &Some(vec![new_pattern("./")]), &None);
+            assert!(retain, "include: ./");
+        }
+
+        {
+            let retain = repo.should_retain_commit(&commit, &Some(vec![new_pattern("**")]), &None);
+            assert!(retain, "include: **");
+        }
+
+        {
+            let retain = repo.should_retain_commit(&commit, &Some(vec![new_pattern("*")]), &None);
+            assert!(retain, "include: *");
+        }
+
+        {
+            let retain =
+                repo.should_retain_commit(&commit, &Some(vec![new_pattern("dir/")]), &None);
+            assert!(retain, "include: dir/");
+        }
+
+        {
+            let retain =
+                repo.should_retain_commit(&commit, &Some(vec![new_pattern("dir/*")]), &None);
+            assert!(retain, "include: dir/*");
+        }
+
+        {
+            let retain =
+                repo.should_retain_commit(&commit, &Some(vec![new_pattern("file1.txt")]), &None);
+            assert!(retain, "include: file1.txt");
+        }
+
+        {
+            let retain =
+                repo.should_retain_commit(&commit, &None, &Some(vec![new_pattern("file1.txt")]));
+            assert!(retain, "exclude: file1.txt");
+        }
+
+        {
+            let retain = repo.should_retain_commit(
+                &commit,
+                &Some(vec![new_pattern("file1.txt")]),
+                &Some(vec![new_pattern("file2.txt")]),
+            );
+            assert!(retain, "include: file1.txt, exclude: file2.txt");
+        }
+
+        {
+            let retain =
+                repo.should_retain_commit(&commit, &None, &Some(vec![new_pattern("**/*.txt")]));
+            assert!(!retain, "exclude: **/*.txt");
+        }
+    }
 }
diff --git a/git-cliff-core/src/tag.rs b/git-cliff-core/src/tag.rs
index 7fe8ab9cb3..16bcfa5882 100644
--- a/git-cliff-core/src/tag.rs
+++ b/git-cliff-core/src/tag.rs
@@ -3,45 +3,45 @@
 /// Lightweight tags will have `None` as message.
 #[derive(Debug)]
 pub struct Tag {
-	/// The name of the tag
-	pub name:    String,
-	/// The message of the tag (only if it was annotated).
-	pub message: Option<String>,
+    /// The name of the tag
+    pub name: String,
+    /// The message of the tag (only if it was annotated).
+    pub message: Option<String>,
 }
 
 #[cfg(test)]
 mod test {
-	use super::*;
+    use super::*;
 
-	#[test]
-	fn create_tag_with_name_and_message() {
-		let tag = Tag {
-			name:    String::from("v1.0"),
-			message: Some(String::from("Initial release")),
-		};
-		assert_eq!(tag.name, "v1.0");
-		assert_eq!(tag.message, Some(String::from("Initial release")));
-	}
+    #[test]
+    fn create_tag_with_name_and_message() {
+        let tag = Tag {
+            name: String::from("v1.0"),
+            message: Some(String::from("Initial release")),
+        };
+        assert_eq!(tag.name, "v1.0");
+        assert_eq!(tag.message, Some(String::from("Initial release")));
+    }
 
-	#[test]
-	fn create_tag_with_name_and_no_message() {
-		let tag = Tag {
-			name:    String::from("v1.0"),
-			message: None,
-		};
-		assert_eq!(tag.name, "v1.0");
-		assert_eq!(tag.message, None);
-	}
+    #[test]
+    fn create_tag_with_name_and_no_message() {
+        let tag = Tag {
+            name: String::from("v1.0"),
+            message: None,
+        };
+        assert_eq!(tag.name, "v1.0");
+        assert_eq!(tag.message, None);
+    }
 
-	#[test]
-	fn debug_print_tag_with_message() {
-		let tag = Tag {
-			name:    String::from("v1.0"),
-			message: Some(String::from("Initial release")),
-		};
-		assert_eq!(
-			format!("{:?}", tag),
-			"Tag { name: \"v1.0\", message: Some(\"Initial release\") }"
-		);
-	}
+    #[test]
+    fn debug_print_tag_with_message() {
+        let tag = Tag {
+            name: String::from("v1.0"),
+            message: Some(String::from("Initial release")),
+        };
+        assert_eq!(
+            format!("{:?}", tag),
+            "Tag { name: \"v1.0\", message: Some(\"Initial release\") }"
+        );
+    }
 }
diff --git a/git-cliff-core/src/template.rs b/git-cliff-core/src/template.rs
index 0d280082a3..a312c24f03 100644
--- a/git-cliff-core/src/template.rs
+++ b/git-cliff-core/src/template.rs
@@ -1,316 +1,287 @@
 use crate::{
-	config::TextProcessor,
-	error::{
-		Error,
-		Result,
-	},
+    config::TextProcessor,
+    error::{Error, Result},
 };
 use serde::Serialize;
-use std::collections::{
-	HashMap,
-	HashSet,
-};
+use std::collections::{HashMap, HashSet};
 use std::error::Error as ErrorImpl;
-use tera::{
-	ast,
-	Context as TeraContext,
-	Result as TeraResult,
-	Tera,
-	Value,
-};
+use tera::{ast, Context as TeraContext, Result as TeraResult, Tera, Value};
 
 /// Wrapper for [`Tera`].
 #[derive(Debug)]
 pub struct Template {
-	/// Template name.
-	name:          String,
-	/// Internal Tera instance.
-	tera:          Tera,
-	/// Template variables.
-	#[cfg_attr(not(feature = "github"), allow(dead_code))]
-	pub variables: Vec<String>,
+    /// Template name.
+    name: String,
+    /// Internal Tera instance.
+    tera: Tera,
+    /// Template variables.
+    #[cfg_attr(not(feature = "github"), allow(dead_code))]
+    pub variables: Vec<String>,
 }
 
 impl Template {
-	/// Constructs a new instance.
-	pub fn new(name: &str, mut content: String, trim: bool) -> Result<Self> {
-		if trim {
-			content = content
-				.lines()
-				.map(|v| v.trim())
-				.collect::<Vec<&str>>()
-				.join("\n");
-		}
-		let mut tera = Tera::default();
-		if let Err(e) = tera.add_raw_template(name, &content) {
-			return if let Some(error_source) = e.source() {
-				Err(Error::TemplateParseError(error_source.to_string()))
-			} else {
-				Err(Error::TemplateError(e))
-			};
-		}
-		tera.register_filter("upper_first", Self::upper_first_filter);
-		Ok(Self {
-			name: name.to_string(),
-			variables: Self::get_template_variables(name, &tera)?,
-			tera,
-		})
-	}
+    /// Constructs a new instance.
+    pub fn new(name: &str, mut content: String, trim: bool) -> Result<Self> {
+        if trim {
+            content = content
+                .lines()
+                .map(|v| v.trim())
+                .collect::<Vec<&str>>()
+                .join("\n");
+        }
+        let mut tera = Tera::default();
+        if let Err(e) = tera.add_raw_template(name, &content) {
+            return if let Some(error_source) = e.source() {
+                Err(Error::TemplateParseError(error_source.to_string()))
+            } else {
+                Err(Error::TemplateError(e))
+            };
+        }
+        tera.register_filter("upper_first", Self::upper_first_filter);
+        Ok(Self {
+            name: name.to_string(),
+            variables: Self::get_template_variables(name, &tera)?,
+            tera,
+        })
+    }
 
-	/// Filter for making the first character of a string uppercase.
-	fn upper_first_filter(
-		value: &Value,
-		_: &HashMap<String, Value>,
-	) -> TeraResult<Value> {
-		let mut s =
-			tera::try_get_value!("upper_first_filter", "value", String, value);
-		let mut c = s.chars();
-		s = match c.next() {
-			None => String::new(),
-			Some(f) => f.to_uppercase().collect::<String>() + c.as_str(),
-		};
-		Ok(tera::to_value(&s)?)
-	}
+    /// Filter for making the first character of a string uppercase.
+    fn upper_first_filter(value: &Value, _: &HashMap<String, Value>) -> TeraResult<Value> {
+        let mut s = tera::try_get_value!("upper_first_filter", "value", String, value);
+        let mut c = s.chars();
+        s = match c.next() {
+            None => String::new(),
+            Some(f) => f.to_uppercase().collect::<String>() + c.as_str(),
+        };
+        Ok(tera::to_value(&s)?)
+    }
 
-	/// Recursively finds the identifiers from the AST.
-	fn find_identifiers(node: &ast::Node, names: &mut HashSet<String>) {
-		match node {
-			ast::Node::Block(_, block, _) => {
-				for node in &block.body {
-					Self::find_identifiers(node, names);
-				}
-			}
-			ast::Node::VariableBlock(_, expr) => {
-				if let ast::ExprVal::Ident(v) = &expr.val {
-					names.insert(v.clone());
-				}
-			}
-			ast::Node::MacroDefinition(_, def, _) => {
-				for node in &def.body {
-					Self::find_identifiers(node, names);
-				}
-			}
-			ast::Node::FilterSection(_, section, _) => {
-				for node in &section.body {
-					Self::find_identifiers(node, names);
-				}
-			}
-			ast::Node::Forloop(_, forloop, _) => {
-				if let ast::ExprVal::Ident(v) = &forloop.container.val {
-					names.insert(v.clone());
-				}
-				for node in &forloop.body {
-					Self::find_identifiers(node, names);
-				}
-				for node in &forloop.empty_body.clone().unwrap_or_default() {
-					Self::find_identifiers(node, names);
-				}
-				for (_, expr) in
-					forloop.container.filters.iter().flat_map(|v| v.args.iter())
-				{
-					if let ast::ExprVal::String(ref v) = expr.val {
-						names.insert(v.clone());
-					}
-				}
-			}
-			ast::Node::If(cond, _) => {
-				for (_, expr, nodes) in &cond.conditions {
-					if let ast::ExprVal::Ident(v) = &expr.val {
-						names.insert(v.clone());
-					}
-					for node in nodes {
-						Self::find_identifiers(node, names);
-					}
-				}
-				if let Some((_, nodes)) = &cond.otherwise {
-					for node in nodes {
-						Self::find_identifiers(node, names);
-					}
-				}
-			}
-			_ => {}
-		}
-	}
+    /// Recursively finds the identifiers from the AST.
+    fn find_identifiers(node: &ast::Node, names: &mut HashSet<String>) {
+        match node {
+            ast::Node::Block(_, block, _) => {
+                for node in &block.body {
+                    Self::find_identifiers(node, names);
+                }
+            }
+            ast::Node::VariableBlock(_, expr) => {
+                if let ast::ExprVal::Ident(v) = &expr.val {
+                    names.insert(v.clone());
+                }
+            }
+            ast::Node::MacroDefinition(_, def, _) => {
+                for node in &def.body {
+                    Self::find_identifiers(node, names);
+                }
+            }
+            ast::Node::FilterSection(_, section, _) => {
+                for node in &section.body {
+                    Self::find_identifiers(node, names);
+                }
+            }
+            ast::Node::Forloop(_, forloop, _) => {
+                if let ast::ExprVal::Ident(v) = &forloop.container.val {
+                    names.insert(v.clone());
+                }
+                for node in &forloop.body {
+                    Self::find_identifiers(node, names);
+                }
+                for node in &forloop.empty_body.clone().unwrap_or_default() {
+                    Self::find_identifiers(node, names);
+                }
+                for (_, expr) in forloop.container.filters.iter().flat_map(|v| v.args.iter()) {
+                    if let ast::ExprVal::String(ref v) = expr.val {
+                        names.insert(v.clone());
+                    }
+                }
+            }
+            ast::Node::If(cond, _) => {
+                for (_, expr, nodes) in &cond.conditions {
+                    if let ast::ExprVal::Ident(v) = &expr.val {
+                        names.insert(v.clone());
+                    }
+                    for node in nodes {
+                        Self::find_identifiers(node, names);
+                    }
+                }
+                if let Some((_, nodes)) = &cond.otherwise {
+                    for node in nodes {
+                        Self::find_identifiers(node, names);
+                    }
+                }
+            }
+            _ => {}
+        }
+    }
 
-	/// Returns the variable names that are used in the template.
-	fn get_template_variables(name: &str, tera: &Tera) -> Result<Vec<String>> {
-		let mut variables = HashSet::new();
-		let ast = &tera.get_template(name)?.ast;
-		for node in ast {
-			Self::find_identifiers(node, &mut variables);
-		}
-		trace!("Template variables for {name}: {variables:?}");
-		Ok(variables.into_iter().collect())
-	}
+    /// Returns the variable names that are used in the template.
+    fn get_template_variables(name: &str, tera: &Tera) -> Result<Vec<String>> {
+        let mut variables = HashSet::new();
+        let ast = &tera.get_template(name)?.ast;
+        for node in ast {
+            Self::find_identifiers(node, &mut variables);
+        }
+        trace!("Template variables for {name}: {variables:?}");
+        Ok(variables.into_iter().collect())
+    }
 
-	/// Returns `true` if the template contains one of the given variables.
-	pub(crate) fn contains_variable(&self, variables: &[&str]) -> bool {
-		variables
-			.iter()
-			.any(|var| self.variables.iter().any(|v| v.starts_with(var)))
-	}
+    /// Returns `true` if the template contains one of the given variables.
+    pub(crate) fn contains_variable(&self, variables: &[&str]) -> bool {
+        variables
+            .iter()
+            .any(|var| self.variables.iter().any(|v| v.starts_with(var)))
+    }
 
-	/// Renders the template.
-	pub fn render<C: Serialize, T: Serialize, S: Into<String> + Clone>(
-		&self,
-		context: &C,
-		additional_context: Option<&HashMap<S, T>>,
-		postprocessors: &[TextProcessor],
-	) -> Result<String> {
-		let mut context = TeraContext::from_serialize(context)?;
-		if let Some(additional_context) = additional_context {
-			for (key, value) in additional_context {
-				context.insert(key.clone(), &value);
-			}
-		}
-		match self.tera.render(&self.name, &context) {
-			Ok(mut v) => {
-				for postprocessor in postprocessors {
-					postprocessor.replace(&mut v, vec![])?;
-				}
-				Ok(v)
-			}
-			Err(e) => {
-				if let Some(source1) = e.source() {
-					if let Some(source2) = source1.source() {
-						Err(Error::TemplateRenderDetailedError(
-							source1.to_string(),
-							source2.to_string(),
-						))
-					} else {
-						Err(Error::TemplateRenderError(source1.to_string()))
-					}
-				} else {
-					Err(Error::TemplateError(e))
-				}
-			}
-		}
-	}
+    /// Renders the template.
+    pub fn render<C: Serialize, T: Serialize, S: Into<String> + Clone>(
+        &self,
+        context: &C,
+        additional_context: Option<&HashMap<S, T>>,
+        postprocessors: &[TextProcessor],
+    ) -> Result<String> {
+        let mut context = TeraContext::from_serialize(context)?;
+        if let Some(additional_context) = additional_context {
+            for (key, value) in additional_context {
+                context.insert(key.clone(), &value);
+            }
+        }
+        match self.tera.render(&self.name, &context) {
+            Ok(mut v) => {
+                for postprocessor in postprocessors {
+                    postprocessor.replace(&mut v, vec![])?;
+                }
+                Ok(v)
+            }
+            Err(e) => {
+                if let Some(source1) = e.source() {
+                    if let Some(source2) = source1.source() {
+                        Err(Error::TemplateRenderDetailedError(
+                            source1.to_string(),
+                            source2.to_string(),
+                        ))
+                    } else {
+                        Err(Error::TemplateRenderError(source1.to_string()))
+                    }
+                } else {
+                    Err(Error::TemplateError(e))
+                }
+            }
+        }
+    }
 }
 
 #[cfg(test)]
 mod test {
-	use super::*;
-	use crate::{
-		commit::Commit,
-		release::Release,
-	};
-	use regex::Regex;
+    use super::*;
+    use crate::{commit::Commit, release::Release};
+    use regex::Regex;
 
-	fn get_fake_release_data() -> Release<'static> {
-		Release {
-			version: Some(String::from("1.0")),
-			message: None,
-			extra: None,
-			commits: vec![
-				Commit::new(
-					String::from("123123"),
-					String::from("feat(xyz): add xyz"),
-				),
-				Commit::new(
-					String::from("124124"),
-					String::from("fix(abc): fix abc"),
-				),
-			]
-			.into_iter()
-			.filter_map(|c| c.into_conventional().ok())
-			.collect(),
-			commit_id: None,
-			timestamp: 0,
-			previous: None,
-			repository: Some(String::from("/root/repo")),
-			#[cfg(feature = "github")]
-			github: crate::remote::RemoteReleaseMetadata {
-				contributors: vec![],
-			},
-			#[cfg(feature = "gitlab")]
-			gitlab: crate::remote::RemoteReleaseMetadata {
-				contributors: vec![],
-			},
-			#[cfg(feature = "gitea")]
-			gitea: crate::remote::RemoteReleaseMetadata {
-				contributors: vec![],
-			},
-			#[cfg(feature = "bitbucket")]
-			bitbucket: crate::remote::RemoteReleaseMetadata {
-				contributors: vec![],
-			},
-		}
-	}
+    fn get_fake_release_data() -> Release<'static> {
+        Release {
+            version: Some(String::from("1.0")),
+            message: None,
+            extra: None,
+            commits: vec![
+                Commit::new(String::from("123123"), String::from("feat(xyz): add xyz")),
+                Commit::new(String::from("124124"), String::from("fix(abc): fix abc")),
+            ]
+            .into_iter()
+            .filter_map(|c| c.into_conventional().ok())
+            .collect(),
+            commit_id: None,
+            timestamp: 0,
+            previous: None,
+            repository: Some(String::from("/root/repo")),
+            #[cfg(feature = "github")]
+            github: crate::remote::RemoteReleaseMetadata {
+                contributors: vec![],
+            },
+            #[cfg(feature = "gitlab")]
+            gitlab: crate::remote::RemoteReleaseMetadata {
+                contributors: vec![],
+            },
+            #[cfg(feature = "gitea")]
+            gitea: crate::remote::RemoteReleaseMetadata {
+                contributors: vec![],
+            },
+            #[cfg(feature = "bitbucket")]
+            bitbucket: crate::remote::RemoteReleaseMetadata {
+                contributors: vec![],
+            },
+        }
+    }
 
-	#[test]
-	fn render_template() -> Result<()> {
-		let template = r#"
+    #[test]
+    fn render_template() -> Result<()> {
+        let template = r#"
 		## {{ version }} - <DATE>
 		{% for commit in commits %}
 		### {{ commit.group }}
 		- {{ commit.message | upper_first }}
 		{% endfor %}"#;
-		let mut template = Template::new("test", template.to_string(), false)?;
-		let release = get_fake_release_data();
-		assert_eq!(
-			"\n\t\t## 1.0 - 2023\n\t\t\n\t\t### feat\n\t\t- Add xyz\n\t\t\n\t\t### \
+        let mut template = Template::new("test", template.to_string(), false)?;
+        let release = get_fake_release_data();
+        assert_eq!(
+            "\n\t\t## 1.0 - 2023\n\t\t\n\t\t### feat\n\t\t- Add xyz\n\t\t\n\t\t### \
 			 fix\n\t\t- Fix abc\n\t\t",
-			template.render(
-				&release,
-				Option::<HashMap<&str, String>>::None.as_ref(),
-				&[TextProcessor {
-					pattern:         Regex::new("<DATE>")
-						.expect("failed to compile regex"),
-					replace:         Some(String::from("2023")),
-					replace_command: None,
-				}],
-			)?
-		);
-		template.variables.sort();
-		assert_eq!(
-			vec![
-				String::from("commit.group"),
-				String::from("commit.message"),
-				String::from("commits"),
-				String::from("version"),
-			],
-			template.variables
-		);
-		#[cfg(feature = "github")]
-		{
-			assert!(!template.contains_variable(&["commit.github"]));
-			assert!(template.contains_variable(&["commit.group"]));
-		}
-		Ok(())
-	}
+            template.render(
+                &release,
+                Option::<HashMap<&str, String>>::None.as_ref(),
+                &[TextProcessor {
+                    pattern: Regex::new("<DATE>").expect("failed to compile regex"),
+                    replace: Some(String::from("2023")),
+                    replace_command: None,
+                }],
+            )?
+        );
+        template.variables.sort();
+        assert_eq!(
+            vec![
+                String::from("commit.group"),
+                String::from("commit.message"),
+                String::from("commits"),
+                String::from("version"),
+            ],
+            template.variables
+        );
+        #[cfg(feature = "github")]
+        {
+            assert!(!template.contains_variable(&["commit.github"]));
+            assert!(template.contains_variable(&["commit.group"]));
+        }
+        Ok(())
+    }
 
-	#[test]
-	fn render_trimmed_template() -> Result<()> {
-		let template = r#"
+    #[test]
+    fn render_trimmed_template() -> Result<()> {
+        let template = r#"
 		##  {{ version }}
 		"#;
-		let template = Template::new("test", template.to_string(), true)?;
-		let release = get_fake_release_data();
-		assert_eq!(
-			"\n##  1.0\n",
-			template.render(
-				&release,
-				Option::<HashMap<&str, String>>::None.as_ref(),
-				&[],
-			)?
-		);
-		assert_eq!(vec![String::from("version"),], template.variables);
-		Ok(())
-	}
+        let template = Template::new("test", template.to_string(), true)?;
+        let release = get_fake_release_data();
+        assert_eq!(
+            "\n##  1.0\n",
+            template.render(
+                &release,
+                Option::<HashMap<&str, String>>::None.as_ref(),
+                &[],
+            )?
+        );
+        assert_eq!(vec![String::from("version"),], template.variables);
+        Ok(())
+    }
 
-	#[test]
-	fn test_upper_first_filter() -> Result<()> {
-		let template =
-			"{% set hello_variable = 'hello' %}{{ hello_variable | upper_first }}";
-		let release = get_fake_release_data();
-		let template = Template::new("test", template.to_string(), true)?;
-		let r = template.render(
-			&release,
-			Option::<HashMap<&str, String>>::None.as_ref(),
-			&[],
-		)?;
-		assert_eq!("Hello", r);
-		Ok(())
-	}
+    #[test]
+    fn test_upper_first_filter() -> Result<()> {
+        let template = "{% set hello_variable = 'hello' %}{{ hello_variable | upper_first }}";
+        let release = get_fake_release_data();
+        let template = Template::new("test", template.to_string(), true)?;
+        let r = template.render(
+            &release,
+            Option::<HashMap<&str, String>>::None.as_ref(),
+            &[],
+        )?;
+        assert_eq!("Hello", r);
+        Ok(())
+    }
 }
diff --git a/git-cliff-core/tests/integration_test.rs b/git-cliff-core/tests/integration_test.rs
index 2676d21c77..f28ed92a83 100644
--- a/git-cliff-core/tests/integration_test.rs
+++ b/git-cliff-core/tests/integration_test.rs
@@ -1,14 +1,5 @@
-use git_cliff_core::commit::{
-	Commit,
-	Signature,
-};
-use git_cliff_core::config::{
-	ChangelogConfig,
-	CommitParser,
-	GitConfig,
-	LinkParser,
-	TextProcessor,
-};
+use git_cliff_core::commit::{Commit, Signature};
+use git_cliff_core::config::{ChangelogConfig, CommitParser, GitConfig, LinkParser, TextProcessor};
 use git_cliff_core::error::Result;
 use git_cliff_core::release::*;
 use git_cliff_core::template::Template;
@@ -19,10 +10,10 @@ use std::fmt::Write;
 
 #[test]
 fn generate_changelog() -> Result<()> {
-	let changelog_config = ChangelogConfig {
-		header:         Some(String::from("this is a changelog")),
-		body:           Some(String::from(
-			r#"
+    let changelog_config = ChangelogConfig {
+        header: Some(String::from("this is a changelog")),
+        body: Some(String::from(
+            r#"
 ## Release {{ version }} - <DATE>
 {% for group, commits in commits | group_by(attribute="group") %}
 ### {{ group }}
@@ -37,120 +28,120 @@ fn generate_changelog() -> Result<()> {
 {% endif -%}
 {% endfor -%}
 {% endfor %}"#,
-		)),
-		footer:         Some(String::from("eoc - end of changelog")),
-		trim:           None,
-		render_always:  None,
-		postprocessors: None,
-		output:         None,
-	};
-	let git_config = GitConfig {
-		conventional_commits:     Some(true),
-		filter_unconventional:    Some(true),
-		split_commits:            Some(false),
-		commit_preprocessors:     Some(vec![TextProcessor {
-			pattern:         Regex::new(r"\(fixes (#[1-9]+)\)").unwrap(),
-			replace:         Some(String::from("[closes Issue${1}]")),
-			replace_command: None,
-		}]),
-		commit_parsers:           Some(vec![
-			CommitParser {
-				sha:           Some(String::from("coffee")),
-				message:       None,
-				body:          None,
-				footer:        None,
-				group:         Some(String::from("I love coffee")),
-				default_scope: None,
-				scope:         None,
-				skip:          None,
-				field:         None,
-				pattern:       None,
-			},
-			CommitParser {
-				sha:           None,
-				message:       Regex::new("^feat").ok(),
-				body:          None,
-				footer:        None,
-				group:         Some(String::from("shiny features")),
-				default_scope: None,
-				scope:         None,
-				skip:          None,
-				field:         None,
-				pattern:       None,
-			},
-			CommitParser {
-				sha:           None,
-				message:       Regex::new("^fix").ok(),
-				body:          None,
-				footer:        None,
-				group:         Some(String::from("fix bugs")),
-				default_scope: None,
-				scope:         None,
-				skip:          None,
-				field:         None,
-				pattern:       None,
-			},
-			CommitParser {
-				sha:           None,
-				message:       Regex::new("^test").ok(),
-				body:          None,
-				footer:        None,
-				group:         None,
-				default_scope: None,
-				scope:         Some(String::from("tests")),
-				skip:          None,
-				field:         None,
-				pattern:       None,
-			},
-			CommitParser {
-				sha:           None,
-				message:       None,
-				body:          None,
-				footer:        None,
-				group:         Some(String::from("docs")),
-				default_scope: None,
-				scope:         None,
-				skip:          None,
-				field:         Some(String::from("author.name")),
-				pattern:       Regex::new("John Doe").ok(),
-			},
-		]),
-		protect_breaking_commits: None,
-		filter_commits:           Some(true),
-		tag_pattern:              None,
-		skip_tags:                None,
-		ignore_tags:              None,
-		count_tags:               None,
-		use_branch_tags:          None,
-		topo_order:               None,
-		sort_commits:             None,
-		link_parsers:             Some(vec![
-			LinkParser {
-				pattern: Regex::new("#(\\d+)").unwrap(),
-				href:    String::from("https://github.com/$1"),
-				text:    None,
-			},
-			LinkParser {
-				pattern: Regex::new("https://github.com/(.*)").unwrap(),
-				href:    String::from("https://github.com/$1"),
-				text:    Some(String::from("$1")),
-			},
-		]),
-		limit_commits:            None,
-	};
+        )),
+        footer: Some(String::from("eoc - end of changelog")),
+        trim: None,
+        render_always: None,
+        postprocessors: None,
+        output: None,
+    };
+    let git_config = GitConfig {
+        conventional_commits: Some(true),
+        filter_unconventional: Some(true),
+        split_commits: Some(false),
+        commit_preprocessors: Some(vec![TextProcessor {
+            pattern: Regex::new(r"\(fixes (#[1-9]+)\)").unwrap(),
+            replace: Some(String::from("[closes Issue${1}]")),
+            replace_command: None,
+        }]),
+        commit_parsers: Some(vec![
+            CommitParser {
+                sha: Some(String::from("coffee")),
+                message: None,
+                body: None,
+                footer: None,
+                group: Some(String::from("I love coffee")),
+                default_scope: None,
+                scope: None,
+                skip: None,
+                field: None,
+                pattern: None,
+            },
+            CommitParser {
+                sha: None,
+                message: Regex::new("^feat").ok(),
+                body: None,
+                footer: None,
+                group: Some(String::from("shiny features")),
+                default_scope: None,
+                scope: None,
+                skip: None,
+                field: None,
+                pattern: None,
+            },
+            CommitParser {
+                sha: None,
+                message: Regex::new("^fix").ok(),
+                body: None,
+                footer: None,
+                group: Some(String::from("fix bugs")),
+                default_scope: None,
+                scope: None,
+                skip: None,
+                field: None,
+                pattern: None,
+            },
+            CommitParser {
+                sha: None,
+                message: Regex::new("^test").ok(),
+                body: None,
+                footer: None,
+                group: None,
+                default_scope: None,
+                scope: Some(String::from("tests")),
+                skip: None,
+                field: None,
+                pattern: None,
+            },
+            CommitParser {
+                sha: None,
+                message: None,
+                body: None,
+                footer: None,
+                group: Some(String::from("docs")),
+                default_scope: None,
+                scope: None,
+                skip: None,
+                field: Some(String::from("author.name")),
+                pattern: Regex::new("John Doe").ok(),
+            },
+        ]),
+        protect_breaking_commits: None,
+        filter_commits: Some(true),
+        tag_pattern: None,
+        skip_tags: None,
+        ignore_tags: None,
+        count_tags: None,
+        use_branch_tags: None,
+        topo_order: None,
+        sort_commits: None,
+        link_parsers: Some(vec![
+            LinkParser {
+                pattern: Regex::new("#(\\d+)").unwrap(),
+                href: String::from("https://github.com/$1"),
+                text: None,
+            },
+            LinkParser {
+                pattern: Regex::new("https://github.com/(.*)").unwrap(),
+                href: String::from("https://github.com/$1"),
+                text: Some(String::from("$1")),
+            },
+        ]),
+        limit_commits: None,
+    };
 
-	let mut commit_with_author = Commit::new(
-		String::from("hjdfas32"),
-		String::from("docs(cool): testing author filtering"),
-	);
+    let mut commit_with_author = Commit::new(
+        String::from("hjdfas32"),
+        String::from("docs(cool): testing author filtering"),
+    );
 
-	commit_with_author.author = Signature {
-		name:      Some("John Doe".to_string()),
-		email:     None,
-		timestamp: 0x0,
-	};
+    commit_with_author.author = Signature {
+        name: Some("John Doe".to_string()),
+        email: None,
+        timestamp: 0x0,
+    };
 
-	let releases = vec![
+    let releases = vec![
 		Release {
 			version:   Some(String::from("v2.0.0")),
 			message: None,
@@ -262,30 +253,30 @@ fn generate_changelog() -> Result<()> {
 		},
 	];
 
-	let out = &mut String::new();
-	let template = Template::new("test", changelog_config.body.unwrap(), false)?;
+    let out = &mut String::new();
+    let template = Template::new("test", changelog_config.body.unwrap(), false)?;
 
-	writeln!(out, "{}", changelog_config.header.unwrap()).unwrap();
-	for release in releases {
-		write!(
-			out,
-			"{}",
-			template.render(
-				&release,
-				Option::<HashMap<&str, String>>::None.as_ref(),
-				&[TextProcessor {
-					pattern:         Regex::new("<DATE>").unwrap(),
-					replace:         Some(String::from("2023")),
-					replace_command: None,
-				}]
-			)?
-		)
-		.unwrap();
-	}
-	writeln!(out, "{}", changelog_config.footer.unwrap()).unwrap();
+    writeln!(out, "{}", changelog_config.header.unwrap()).unwrap();
+    for release in releases {
+        write!(
+            out,
+            "{}",
+            template.render(
+                &release,
+                Option::<HashMap<&str, String>>::None.as_ref(),
+                &[TextProcessor {
+                    pattern: Regex::new("<DATE>").unwrap(),
+                    replace: Some(String::from("2023")),
+                    replace_command: None,
+                }]
+            )?
+        )
+        .unwrap();
+    }
+    writeln!(out, "{}", changelog_config.footer.unwrap()).unwrap();
 
-	assert_eq!(
-		r#"this is a changelog
+    assert_eq!(
+        r#"this is a changelog
 
 ## Release v2.0.0 - 2023
 
@@ -319,8 +310,8 @@ fn generate_changelog() -> Result<()> {
 - fix more stuff
 eoc - end of changelog
 "#,
-		out
-	);
+        out
+    );
 
-	Ok(())
+    Ok(())
 }
diff --git a/git-cliff/src/args.rs b/git-cliff/src/args.rs
index 6241624323..179423c86b 100644
--- a/git-cliff/src/args.rs
+++ b/git-cliff/src/args.rs
@@ -1,28 +1,13 @@
 use clap::{
-	builder::{
-		styling::{
-			Ansi256Color,
-			AnsiColor,
-		},
-		Styles,
-		TypedValueParser,
-		ValueParserFactory,
-	},
-	error::{
-		ContextKind,
-		ContextValue,
-		ErrorKind,
-	},
-	ArgAction,
-	Parser,
-	ValueEnum,
-};
-use git_cliff_core::{
-	config::BumpType,
-	config::Remote,
-	DEFAULT_CONFIG,
-	DEFAULT_OUTPUT,
+    builder::{
+        styling::{Ansi256Color, AnsiColor},
+        Styles, TypedValueParser, ValueParserFactory,
+    },
+    error::{ContextKind, ContextValue, ErrorKind},
+    ArgAction, Parser, ValueEnum,
 };
+use git_cliff_core::{config::BumpType, config::Remote, DEFAULT_CONFIG, DEFAULT_OUTPUT};
+use git_cliff_core::{config::BumpType, config::Remote, DEFAULT_CONFIG, DEFAULT_OUTPUT};
 use glob::Pattern;
 use regex::Regex;
 use secrecy::SecretString;
@@ -31,22 +16,22 @@ use url::Url;
 
 #[derive(Debug, Clone, Copy, ValueEnum)]
 pub enum Strip {
-	Header,
-	Footer,
-	All,
+    Header,
+    Footer,
+    All,
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, ValueEnum)]
 pub enum Sort {
-	Oldest,
-	Newest,
+    Oldest,
+    Newest,
 }
 
 const STYLES: Styles = Styles::styled()
-	.header(Ansi256Color(208).on_default().bold())
-	.usage(Ansi256Color(208).on_default().bold())
-	.literal(AnsiColor::White.on_default())
-	.placeholder(AnsiColor::Green.on_default());
+    .header(Ansi256Color(208).on_default().bold())
+    .usage(Ansi256Color(208).on_default().bold())
+    .literal(AnsiColor::White.on_default())
+    .placeholder(AnsiColor::Green.on_default());
 
 /// Command-line arguments to parse.
 #[derive(Debug, Parser)]
@@ -70,7 +55,7 @@ const STYLES: Styles = Styles::styled()
     styles(STYLES),
 )]
 pub struct Opt {
-	#[arg(
+    #[arg(
 		short,
 		long,
 		action = ArgAction::Help,
@@ -78,8 +63,8 @@ pub struct Opt {
 		help = "Prints help information",
 		help_heading = "FLAGS"
 	)]
-	pub help:             Option<bool>,
-	#[arg(
+    pub help: Option<bool>,
+    #[arg(
 		short = 'V',
 		long,
 		action = ArgAction::Version,
@@ -87,21 +72,21 @@ pub struct Opt {
 		help = "Prints version information",
 		help_heading = "FLAGS"
 	)]
-	pub version:          Option<bool>,
-	/// Increases the logging verbosity.
-	#[arg(short, long, action = ArgAction::Count, alias = "debug", help_heading = Some("FLAGS"))]
-	pub verbose:          u8,
-	/// Writes the default configuration file to cliff.toml
-	#[arg(
+    pub version: Option<bool>,
+    /// Increases the logging verbosity.
+    #[arg(short, long, action = ArgAction::Count, alias = "debug", help_heading = Some("FLAGS"))]
+    pub verbose: u8,
+    /// Writes the default configuration file to cliff.toml
+    #[arg(
 	    short,
 	    long,
 	    value_name = "CONFIG",
 	    num_args = 0..=1,
 	    required = false
 	)]
-	pub init:             Option<Option<String>>,
-	/// Sets the configuration file.
-	#[arg(
+    pub init: Option<Option<String>>,
+    /// Sets the configuration file.
+    #[arg(
 	    short,
 	    long,
 	    env = "GIT_CLIFF_CONFIG",
@@ -109,18 +94,18 @@ pub struct Opt {
 	    default_value = DEFAULT_CONFIG,
 	    value_parser = Opt::parse_dir
 	)]
-	pub config:           PathBuf,
-	/// Sets the working directory.
-	#[arg(
+    pub config: PathBuf,
+    /// Sets the working directory.
+    #[arg(
 	    short,
 	    long,
 	    env = "GIT_CLIFF_WORKDIR",
 	    value_name = "PATH",
 	    value_parser = Opt::parse_dir
 	)]
-	pub workdir:          Option<PathBuf>,
-	/// Sets the git repository.
-	#[arg(
+    pub workdir: Option<PathBuf>,
+    /// Sets the git repository.
+    #[arg(
 		short,
 		long,
 		env = "GIT_CLIFF_REPOSITORY",
@@ -128,67 +113,67 @@ pub struct Opt {
 		num_args(1..),
 		value_parser = Opt::parse_dir
 	)]
-	pub repository:       Option<Vec<PathBuf>>,
-	/// Sets the path to include related commits.
-	#[arg(
+    pub repository: Option<Vec<PathBuf>>,
+    /// Sets the path to include related commits.
+    #[arg(
 		long,
 		env = "GIT_CLIFF_INCLUDE_PATH",
 		value_name = "PATTERN",
 		num_args(1..)
 	)]
-	pub include_path:     Option<Vec<Pattern>>,
-	/// Sets the path to exclude related commits.
-	#[arg(
+    pub include_path: Option<Vec<Pattern>>,
+    /// Sets the path to exclude related commits.
+    #[arg(
 		long,
 		env = "GIT_CLIFF_EXCLUDE_PATH",
 		value_name = "PATTERN",
 		num_args(1..)
 	)]
-	pub exclude_path:     Option<Vec<Pattern>>,
-	/// Sets the regex for matching git tags.
-	#[arg(long, env = "GIT_CLIFF_TAG_PATTERN", value_name = "PATTERN")]
-	pub tag_pattern:      Option<Regex>,
-	/// Sets custom commit messages to include in the changelog.
-	#[arg(
+    pub exclude_path: Option<Vec<Pattern>>,
+    /// Sets the regex for matching git tags.
+    #[arg(long, env = "GIT_CLIFF_TAG_PATTERN", value_name = "PATTERN")]
+    pub tag_pattern: Option<Regex>,
+    /// Sets custom commit messages to include in the changelog.
+    #[arg(
 		long,
 		env = "GIT_CLIFF_WITH_COMMIT",
 		value_name = "MSG",
 		num_args(1..)
 	)]
-	pub with_commit:      Option<Vec<String>>,
-	/// Sets custom message for the latest release.
-	#[arg(
+    pub with_commit: Option<Vec<String>>,
+    /// Sets custom message for the latest release.
+    #[arg(
 		long,
 		env = "GIT_CLIFF_WITH_TAG_MESSAGE",
 		value_name = "MSG",
 		num_args = 0..=1,
 	)]
-	pub with_tag_message: Option<String>,
-	/// Sets the tags to ignore in the changelog.
-	#[arg(long, env = "GIT_CLIFF_IGNORE_TAGS", value_name = "PATTERN")]
-	pub ignore_tags:      Option<Regex>,
-	/// Sets the tags to count in the changelog.
-	#[arg(long, env = "GIT_CLIFF_COUNT_TAGS", value_name = "PATTERN")]
-	pub count_tags:       Option<Regex>,
-	/// Sets commits that will be skipped in the changelog.
-	#[arg(
+    pub with_tag_message: Option<String>,
+    /// Sets the tags to ignore in the changelog.
+    #[arg(long, env = "GIT_CLIFF_IGNORE_TAGS", value_name = "PATTERN")]
+    pub ignore_tags: Option<Regex>,
+    /// Sets the tags to count in the changelog.
+    #[arg(long, env = "GIT_CLIFF_COUNT_TAGS", value_name = "PATTERN")]
+    pub count_tags: Option<Regex>,
+    /// Sets commits that will be skipped in the changelog.
+    #[arg(
 		long,
 		env = "GIT_CLIFF_SKIP_COMMIT",
 		value_name = "SHA1",
 		num_args(1..)
 	)]
-	pub skip_commit:      Option<Vec<String>>,
-	/// Prepends entries to the given changelog file.
-	#[arg(
+    pub skip_commit: Option<Vec<String>>,
+    /// Prepends entries to the given changelog file.
+    #[arg(
 	    short,
 	    long,
 	    env = "GIT_CLIFF_PREPEND",
 	    value_name = "PATH",
 	    value_parser = Opt::parse_dir
 	)]
-	pub prepend:          Option<PathBuf>,
-	/// Writes output to the given file.
-	#[arg(
+    pub prepend: Option<PathBuf>,
+    /// Writes output to the given file.
+    #[arg(
 	    short,
 	    long,
 	    env = "GIT_CLIFF_OUTPUT",
@@ -197,152 +182,152 @@ pub struct Opt {
 	    num_args = 0..=1,
 	    default_missing_value = DEFAULT_OUTPUT
 	)]
-	pub output:           Option<PathBuf>,
-	/// Sets the tag for the latest version.
-	#[arg(
-		short,
-		long,
-		env = "GIT_CLIFF_TAG",
-		value_name = "TAG",
-		allow_hyphen_values = true
-	)]
-	pub tag:              Option<String>,
-	/// Bumps the version for unreleased changes. Optionally with specified
-	/// version.
-	#[arg(
+    pub output: Option<PathBuf>,
+    /// Sets the tag for the latest version.
+    #[arg(
+        short,
+        long,
+        env = "GIT_CLIFF_TAG",
+        value_name = "TAG",
+        allow_hyphen_values = true
+    )]
+    pub tag: Option<String>,
+    /// Bumps the version for unreleased changes. Optionally with specified
+    /// version.
+    #[arg(
         long,
         value_name = "BUMP",
         value_enum,
         num_args = 0..=1,
         default_missing_value = "auto",
         value_parser = clap::value_parser!(BumpOption))]
-	pub bump:             Option<BumpOption>,
-	/// Prints bumped version for unreleased changes.
-	#[arg(long, help_heading = Some("FLAGS"))]
-	pub bumped_version:   bool,
-	/// Sets the template for the changelog body.
-	#[arg(
-		short,
-		long,
-		env = "GIT_CLIFF_TEMPLATE",
-		value_name = "TEMPLATE",
-		allow_hyphen_values = true
-	)]
-	pub body:             Option<String>,
-	/// Processes the commits starting from the latest tag.
-	#[arg(short, long, help_heading = Some("FLAGS"))]
-	pub latest:           bool,
-	/// Processes the commits that belong to the current tag.
-	#[arg(long, help_heading = Some("FLAGS"))]
-	pub current:          bool,
-	/// Processes the commits that do not belong to a tag.
-	#[arg(short, long, help_heading = Some("FLAGS"))]
-	pub unreleased:       bool,
-	/// Sorts the tags topologically.
-	#[arg(long, help_heading = Some("FLAGS"))]
-	pub topo_order:       bool,
-	/// Include only the tags that belong to the current branch.
-	#[arg(long, help_heading = Some("FLAGS"))]
-	pub use_branch_tags:  bool,
-	/// Disables the external command execution.
-	#[arg(long, help_heading = Some("FLAGS"))]
-	pub no_exec:          bool,
-	/// Prints changelog context as JSON.
-	#[arg(short = 'x', long, help_heading = Some("FLAGS"))]
-	pub context:          bool,
-	/// Generates changelog from a JSON context.
-	#[arg(
+    pub bump: Option<BumpOption>,
+    /// Prints bumped version for unreleased changes.
+    #[arg(long, help_heading = Some("FLAGS"))]
+    pub bumped_version: bool,
+    /// Sets the template for the changelog body.
+    #[arg(
+        short,
+        long,
+        env = "GIT_CLIFF_TEMPLATE",
+        value_name = "TEMPLATE",
+        allow_hyphen_values = true
+    )]
+    pub body: Option<String>,
+    /// Processes the commits starting from the latest tag.
+    #[arg(short, long, help_heading = Some("FLAGS"))]
+    pub latest: bool,
+    /// Processes the commits that belong to the current tag.
+    #[arg(long, help_heading = Some("FLAGS"))]
+    pub current: bool,
+    /// Processes the commits that do not belong to a tag.
+    #[arg(short, long, help_heading = Some("FLAGS"))]
+    pub unreleased: bool,
+    /// Sorts the tags topologically.
+    #[arg(long, help_heading = Some("FLAGS"))]
+    pub topo_order: bool,
+    /// Include only the tags that belong to the current branch.
+    #[arg(long, help_heading = Some("FLAGS"))]
+    pub use_branch_tags: bool,
+    /// Disables the external command execution.
+    #[arg(long, help_heading = Some("FLAGS"))]
+    pub no_exec: bool,
+    /// Prints changelog context as JSON.
+    #[arg(short = 'x', long, help_heading = Some("FLAGS"))]
+    pub context: bool,
+    /// Generates changelog from a JSON context.
+    #[arg(
         long,
 	    value_name = "PATH",
 	    value_parser = Opt::parse_dir,
 		env = "GIT_CLIFF_CONTEXT",
     )]
-	pub from_context:     Option<PathBuf>,
-	/// Strips the given parts from the changelog.
-	#[arg(short, long, value_name = "PART", value_enum)]
-	pub strip:            Option<Strip>,
-	/// Sets sorting of the commits inside sections.
-	#[arg(
+    pub from_context: Option<PathBuf>,
+    /// Strips the given parts from the changelog.
+    #[arg(short, long, value_name = "PART", value_enum)]
+    pub strip: Option<Strip>,
+    /// Sets sorting of the commits inside sections.
+    #[arg(
 		long,
 		value_enum,
 		default_value_t = Sort::Oldest
 	)]
-	pub sort:             Sort,
-	/// Sets the commit range to process.
-	#[arg(value_name = "RANGE", help_heading = Some("ARGS"))]
-	pub range:            Option<String>,
-	/// Sets the GitHub API token.
-	#[arg(
+    pub sort: Sort,
+    /// Sets the commit range to process.
+    #[arg(value_name = "RANGE", help_heading = Some("ARGS"))]
+    pub range: Option<String>,
+    /// Sets the GitHub API token.
+    #[arg(
 		long,
 		env = "GITHUB_TOKEN",
 		value_name = "TOKEN",
 		hide_env_values = true,
 		hide = !cfg!(feature = "github"),
 	)]
-	pub github_token:     Option<SecretString>,
-	/// Sets the GitHub repository.
-	#[arg(
+    pub github_token: Option<SecretString>,
+    /// Sets the GitHub repository.
+    #[arg(
 		long,
 		env = "GITHUB_REPO",
 		value_parser = clap::value_parser!(RemoteValue),
 		value_name = "OWNER/REPO",
 		hide = !cfg!(feature = "github"),
 	)]
-	pub github_repo:      Option<RemoteValue>,
-	/// Sets the GitLab API token.
-	#[arg(
+    pub github_repo: Option<RemoteValue>,
+    /// Sets the GitLab API token.
+    #[arg(
 		long,
 		env = "GITLAB_TOKEN",
 		value_name = "TOKEN",
 		hide_env_values = true,
 		hide = !cfg!(feature = "gitlab"),
 	)]
-	pub gitlab_token:     Option<SecretString>,
-	/// Sets the GitLab repository.
-	#[arg(
+    pub gitlab_token: Option<SecretString>,
+    /// Sets the GitLab repository.
+    #[arg(
 		long,
 		env = "GITLAB_REPO",
 		value_parser = clap::value_parser!(RemoteValue),
 		value_name = "OWNER/REPO",
 		hide = !cfg!(feature = "gitlab"),
 	)]
-	pub gitlab_repo:      Option<RemoteValue>,
-	/// Sets the Gitea API token.
-	#[arg(
+    pub gitlab_repo: Option<RemoteValue>,
+    /// Sets the Gitea API token.
+    #[arg(
 		long,
 		env = "GITEA_TOKEN",
 		value_name = "TOKEN",
 		hide_env_values = true,
 		hide = !cfg!(feature = "gitea"),
 	)]
-	pub gitea_token:      Option<SecretString>,
-	/// Sets the Gitea repository.
-	#[arg(
+    pub gitea_token: Option<SecretString>,
+    /// Sets the Gitea repository.
+    #[arg(
 		long,
 		env = "GITEA_REPO",
 		value_parser = clap::value_parser!(RemoteValue),
 		value_name = "OWNER/REPO",
 		hide = !cfg!(feature = "gitea"),
 	)]
-	pub gitea_repo:       Option<RemoteValue>,
-	/// Sets the Bitbucket API token.
-	#[arg(
+    pub gitea_repo: Option<RemoteValue>,
+    /// Sets the Bitbucket API token.
+    #[arg(
 		long,
 		env = "BITBUCKET_TOKEN",
 		value_name = "TOKEN",
 		hide_env_values = true,
 		hide = !cfg!(feature = "bitbucket"),
 	)]
-	pub bitbucket_token:  Option<SecretString>,
-	/// Sets the Bitbucket repository.
-	#[arg(
+    pub bitbucket_token: Option<SecretString>,
+    /// Sets the Bitbucket repository.
+    #[arg(
 		long,
 		env = "BITBUCKET_REPO",
 		value_parser = clap::value_parser!(RemoteValue),
 		value_name = "OWNER/REPO",
 		hide = !cfg!(feature = "bitbucket"),
 	)]
-	pub bitbucket_repo:   Option<RemoteValue>,
+    pub bitbucket_repo: Option<RemoteValue>,
 }
 
 /// Custom type for the remote value.
@@ -350,10 +335,10 @@ pub struct Opt {
 pub struct RemoteValue(pub Remote);
 
 impl ValueParserFactory for RemoteValue {
-	type Parser = RemoteValueParser;
-	fn value_parser() -> Self::Parser {
-		RemoteValueParser
-	}
+    type Parser = RemoteValueParser;
+    fn value_parser() -> Self::Parser {
+        RemoteValueParser
+    }
 }
 
 /// Parser for the remote value.
@@ -361,49 +346,49 @@ impl ValueParserFactory for RemoteValue {
 pub struct RemoteValueParser;
 
 impl TypedValueParser for RemoteValueParser {
-	type Value = RemoteValue;
-	fn parse_ref(
-		&self,
-		cmd: &clap::Command,
-		arg: Option<&clap::Arg>,
-		value: &std::ffi::OsStr,
-	) -> Result<Self::Value, clap::Error> {
-		let inner = clap::builder::StringValueParser::new();
-		let mut value = inner.parse_ref(cmd, arg, value)?;
-		if let Ok(url) = Url::parse(&value) {
-			value = url.path().trim_start_matches('/').to_string();
-		}
-		let parts = value.rsplit_once('/');
-		if let Some((owner, repo)) = parts {
-			Ok(RemoteValue(Remote::new(
-				owner.to_string(),
-				repo.to_string(),
-			)))
-		} else {
-			let mut err = clap::Error::new(ErrorKind::ValueValidation).with_cmd(cmd);
-			if let Some(arg) = arg {
-				err.insert(
-					ContextKind::InvalidArg,
-					ContextValue::String(arg.to_string()),
-				);
-			}
-			err.insert(ContextKind::InvalidValue, ContextValue::String(value));
-			Err(err)
-		}
-	}
+    type Value = RemoteValue;
+    fn parse_ref(
+        &self,
+        cmd: &clap::Command,
+        arg: Option<&clap::Arg>,
+        value: &std::ffi::OsStr,
+    ) -> Result<Self::Value, clap::Error> {
+        let inner = clap::builder::StringValueParser::new();
+        let mut value = inner.parse_ref(cmd, arg, value)?;
+        if let Ok(url) = Url::parse(&value) {
+            value = url.path().trim_start_matches('/').to_string();
+        }
+        let parts = value.rsplit_once('/');
+        if let Some((owner, repo)) = parts {
+            Ok(RemoteValue(Remote::new(
+                owner.to_string(),
+                repo.to_string(),
+            )))
+        } else {
+            let mut err = clap::Error::new(ErrorKind::ValueValidation).with_cmd(cmd);
+            if let Some(arg) = arg {
+                err.insert(
+                    ContextKind::InvalidArg,
+                    ContextValue::String(arg.to_string()),
+                );
+            }
+            err.insert(ContextKind::InvalidValue, ContextValue::String(value));
+            Err(err)
+        }
+    }
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]
 pub enum BumpOption {
-	Auto,
-	Specific(BumpType),
+    Auto,
+    Specific(BumpType),
 }
 
 impl ValueParserFactory for BumpOption {
-	type Parser = BumpOptionParser;
-	fn value_parser() -> Self::Parser {
-		BumpOptionParser
-	}
+    type Parser = BumpOptionParser;
+    fn value_parser() -> Self::Parser {
+        BumpOptionParser
+    }
 }
 
 /// Parser for bump type.
@@ -411,132 +396,124 @@ impl ValueParserFactory for BumpOption {
 pub struct BumpOptionParser;
 
 impl TypedValueParser for BumpOptionParser {
-	type Value = BumpOption;
-	fn parse_ref(
-		&self,
-		cmd: &clap::Command,
-		arg: Option<&clap::Arg>,
-		value: &std::ffi::OsStr,
-	) -> Result<Self::Value, clap::Error> {
-		let inner = clap::builder::StringValueParser::new();
-		let value = inner.parse_ref(cmd, arg, value)?;
-		match value.as_str() {
-			"auto" => Ok(BumpOption::Auto),
-			"major" => Ok(BumpOption::Specific(BumpType::Major)),
-			"minor" => Ok(BumpOption::Specific(BumpType::Minor)),
-			"patch" => Ok(BumpOption::Specific(BumpType::Patch)),
-			_ => {
-				let mut err =
-					clap::Error::new(ErrorKind::ValueValidation).with_cmd(cmd);
-				if let Some(arg) = arg {
-					err.insert(
-						ContextKind::InvalidArg,
-						ContextValue::String(arg.to_string()),
-					);
-				}
-				err.insert(ContextKind::InvalidValue, ContextValue::String(value));
-				Err(err)
-			}
-		}
-	}
+    type Value = BumpOption;
+    fn parse_ref(
+        &self,
+        cmd: &clap::Command,
+        arg: Option<&clap::Arg>,
+        value: &std::ffi::OsStr,
+    ) -> Result<Self::Value, clap::Error> {
+        let inner = clap::builder::StringValueParser::new();
+        let value = inner.parse_ref(cmd, arg, value)?;
+        match value.as_str() {
+            "auto" => Ok(BumpOption::Auto),
+            "major" => Ok(BumpOption::Specific(BumpType::Major)),
+            "minor" => Ok(BumpOption::Specific(BumpType::Minor)),
+            "patch" => Ok(BumpOption::Specific(BumpType::Patch)),
+            _ => {
+                let mut err = clap::Error::new(ErrorKind::ValueValidation).with_cmd(cmd);
+                if let Some(arg) = arg {
+                    err.insert(
+                        ContextKind::InvalidArg,
+                        ContextValue::String(arg.to_string()),
+                    );
+                }
+                err.insert(ContextKind::InvalidValue, ContextValue::String(value));
+                Err(err)
+            }
+        }
+    }
 }
 
 impl Opt {
-	/// Custom string parser for directories.
-	///
-	/// Expands the tilde (`~`) character in the beginning of the
-	/// input string into contents of the path returned by [`home_dir`].
-	///
-	/// [`home_dir`]: dirs::home_dir
-	fn parse_dir(dir: &str) -> Result<PathBuf, String> {
-		Ok(PathBuf::from(shellexpand::tilde(dir).to_string()))
-	}
+    /// Custom string parser for directories.
+    ///
+    /// Expands the tilde (`~`) character in the beginning of the
+    /// input string into contents of the path returned by [`home_dir`].
+    ///
+    /// [`home_dir`]: dirs::home_dir
+    fn parse_dir(dir: &str) -> Result<PathBuf, String> {
+        Ok(PathBuf::from(shellexpand::tilde(dir).to_string()))
+    }
 }
 
 #[cfg(test)]
 mod tests {
-	use super::*;
-	use clap::CommandFactory;
-	use std::ffi::OsStr;
+    use super::*;
+    use clap::CommandFactory;
+    use std::ffi::OsStr;
 
-	#[test]
-	fn verify_cli() {
-		Opt::command().debug_assert();
-	}
+    #[test]
+    fn verify_cli() {
+        Opt::command().debug_assert();
+    }
 
-	#[test]
-	fn path_tilde_expansion() {
-		let home_dir = dirs::home_dir().expect("cannot retrieve home directory");
-		let dir = Opt::parse_dir("~/").expect("cannot expand tilde");
-		assert_eq!(home_dir, dir);
-	}
+    #[test]
+    fn path_tilde_expansion() {
+        let home_dir = dirs::home_dir().expect("cannot retrieve home directory");
+        let dir = Opt::parse_dir("~/").expect("cannot expand tilde");
+        assert_eq!(home_dir, dir);
+    }
 
-	#[test]
-	fn remote_value_parser() -> Result<(), clap::Error> {
-		let remote_value_parser = RemoteValueParser;
-		assert_eq!(
-			RemoteValue(Remote::new("test", "repo")),
-			remote_value_parser.parse_ref(
-				&Opt::command(),
-				None,
-				OsStr::new("test/repo")
-			)?
-		);
-		assert_eq!(
-			RemoteValue(Remote::new("gitlab/group/test", "repo")),
-			remote_value_parser.parse_ref(
-				&Opt::command(),
-				None,
-				OsStr::new("gitlab/group/test/repo")
-			)?
-		);
-		assert_eq!(
-			RemoteValue(Remote::new("test", "testrepo")),
-			remote_value_parser.parse_ref(
-				&Opt::command(),
-				None,
-				OsStr::new("https://github.com/test/testrepo")
-			)?
-		);
-		assert_eq!(
-			RemoteValue(Remote::new("archlinux/packaging/packages", "arch-repro-status")),
-			remote_value_parser.parse_ref(
-				&Opt::command(),
-				None,
-				OsStr::new("https://gitlab.archlinux.org/archlinux/packaging/packages/arch-repro-status")
-			)?
-		);
-		assert!(remote_value_parser
-			.parse_ref(&Opt::command(), None, OsStr::new("test"))
-			.is_err());
-		assert!(remote_value_parser
-			.parse_ref(&Opt::command(), None, OsStr::new(""))
-			.is_err());
-		Ok(())
-	}
+    #[test]
+    fn remote_value_parser() -> Result<(), clap::Error> {
+        let remote_value_parser = RemoteValueParser;
+        assert_eq!(
+            RemoteValue(Remote::new("test", "repo")),
+            remote_value_parser.parse_ref(&Opt::command(), None, OsStr::new("test/repo"))?
+        );
+        assert_eq!(
+            RemoteValue(Remote::new("gitlab/group/test", "repo")),
+            remote_value_parser.parse_ref(
+                &Opt::command(),
+                None,
+                OsStr::new("gitlab/group/test/repo")
+            )?
+        );
+        assert_eq!(
+            RemoteValue(Remote::new("test", "testrepo")),
+            remote_value_parser.parse_ref(
+                &Opt::command(),
+                None,
+                OsStr::new("https://github.com/test/testrepo")
+            )?
+        );
+        assert_eq!(
+            RemoteValue(Remote::new(
+                "archlinux/packaging/packages",
+                "arch-repro-status"
+            )),
+            remote_value_parser.parse_ref(
+                &Opt::command(),
+                None,
+                OsStr::new(
+                    "https://gitlab.archlinux.org/archlinux/packaging/packages/arch-repro-status"
+                )
+            )?
+        );
+        assert!(remote_value_parser
+            .parse_ref(&Opt::command(), None, OsStr::new("test"))
+            .is_err());
+        assert!(remote_value_parser
+            .parse_ref(&Opt::command(), None, OsStr::new(""))
+            .is_err());
+        Ok(())
+    }
 
-	#[test]
-	fn bump_option_parser() -> Result<(), clap::Error> {
-		let bump_option_parser = BumpOptionParser;
-		assert_eq!(
-			BumpOption::Auto,
-			bump_option_parser.parse_ref(
-				&Opt::command(),
-				None,
-				OsStr::new("auto")
-			)?
-		);
-		assert!(bump_option_parser
-			.parse_ref(&Opt::command(), None, OsStr::new("test"))
-			.is_err());
-		assert_eq!(
-			BumpOption::Specific(BumpType::Major),
-			bump_option_parser.parse_ref(
-				&Opt::command(),
-				None,
-				OsStr::new("major")
-			)?
-		);
-		Ok(())
-	}
+    #[test]
+    fn bump_option_parser() -> Result<(), clap::Error> {
+        let bump_option_parser = BumpOptionParser;
+        assert_eq!(
+            BumpOption::Auto,
+            bump_option_parser.parse_ref(&Opt::command(), None, OsStr::new("auto"))?
+        );
+        assert!(bump_option_parser
+            .parse_ref(&Opt::command(), None, OsStr::new("test"))
+            .is_err());
+        assert_eq!(
+            BumpOption::Specific(BumpType::Major),
+            bump_option_parser.parse_ref(&Opt::command(), None, OsStr::new("major"))?
+        );
+        Ok(())
+    }
 }
diff --git a/git-cliff/src/bin/completions.rs b/git-cliff/src/bin/completions.rs
index d4cd4d5b79..7305ebdc66 100644
--- a/git-cliff/src/bin/completions.rs
+++ b/git-cliff/src/bin/completions.rs
@@ -1,7 +1,4 @@
-use clap::{
-	CommandFactory,
-	ValueEnum,
-};
+use clap::{CommandFactory, ValueEnum};
 use clap_complete::Shell;
 use git_cliff::args::Opt;
 use std::env;
@@ -12,16 +9,11 @@ use std::io::Result;
 /// in a directory specified by the environment variable `OUT_DIR`.
 /// See <https://doc.rust-lang.org/cargo/reference/environment-variables.html>
 fn main() -> Result<()> {
-	let out_dir = env::var("OUT_DIR").expect("OUT_DIR is not set");
-	let mut app = Opt::command();
-	for &shell in Shell::value_variants() {
-		clap_complete::generate_to(
-			shell,
-			&mut app,
-			env!("CARGO_PKG_NAME"),
-			&out_dir,
-		)?;
-	}
-	println!("Completion scripts are generated in {out_dir:?}");
-	Ok(())
+    let out_dir = env::var("OUT_DIR").expect("OUT_DIR is not set");
+    let mut app = Opt::command();
+    for &shell in Shell::value_variants() {
+        clap_complete::generate_to(shell, &mut app, env!("CARGO_PKG_NAME"), &out_dir)?;
+    }
+    println!("Completion scripts are generated in {out_dir:?}");
+    Ok(())
 }
diff --git a/git-cliff/src/bin/mangen.rs b/git-cliff/src/bin/mangen.rs
index 1d0d670430..cbf3d77c7b 100644
--- a/git-cliff/src/bin/mangen.rs
+++ b/git-cliff/src/bin/mangen.rs
@@ -11,14 +11,13 @@ use std::path::PathBuf;
 /// in a directory specified by the environment variable `OUT_DIR`.
 /// See <https://doc.rust-lang.org/cargo/reference/environment-variables.html>
 fn main() -> Result<()> {
-	let out_dir = env::var("OUT_DIR").expect("OUT_DIR is not set");
-	let out_path =
-		PathBuf::from(out_dir).join(format!("{}.1", env!("CARGO_PKG_NAME")));
-	let app = Opt::command();
-	let man = Man::new(app);
-	let mut buffer = Vec::<u8>::new();
-	man.render(&mut buffer)?;
-	fs::write(&out_path, buffer)?;
-	println!("Man page is generated at {out_path:?}");
-	Ok(())
+    let out_dir = env::var("OUT_DIR").expect("OUT_DIR is not set");
+    let out_path = PathBuf::from(out_dir).join(format!("{}.1", env!("CARGO_PKG_NAME")));
+    let app = Opt::command();
+    let man = Man::new(app);
+    let mut buffer = Vec::<u8>::new();
+    man.render(&mut buffer)?;
+    fs::write(&out_path, buffer)?;
+    println!("Man page is generated at {out_path:?}");
+    Ok(())
 }
diff --git a/git-cliff/src/lib.rs b/git-cliff/src/lib.rs
index b2c29f95d9..7237783735 100644
--- a/git-cliff/src/lib.rs
+++ b/git-cliff/src/lib.rs
@@ -1,7 +1,7 @@
 //! A highly customizable changelog generator ⛰️
 #![doc(
-	html_logo_url = "https://raw.githubusercontent.com/orhun/git-cliff/main/website/static/img/git-cliff.png",
-	html_favicon_url = "https://raw.githubusercontent.com/orhun/git-cliff/main/website/static/favicon/favicon.ico"
+    html_logo_url = "https://raw.githubusercontent.com/orhun/git-cliff/main/website/static/img/git-cliff.png",
+    html_favicon_url = "https://raw.githubusercontent.com/orhun/git-cliff/main/website/static/favicon/favicon.ico"
 )]
 
 /// Command-line argument parser.
@@ -13,64 +13,37 @@ pub mod logger;
 #[macro_use]
 extern crate log;
 
-use args::{
-	BumpOption,
-	Opt,
-	Sort,
-	Strip,
-};
+use args::{BumpOption, Opt, Sort, Strip};
 use clap::ValueEnum;
 use git_cliff_core::changelog::Changelog;
 use git_cliff_core::commit::Commit;
-use git_cliff_core::config::{
-	CommitParser,
-	Config,
-};
-use git_cliff_core::embed::{
-	BuiltinConfig,
-	EmbeddedConfig,
-};
-use git_cliff_core::error::{
-	Error,
-	Result,
-};
+use git_cliff_core::config::{CommitParser, Config};
+use git_cliff_core::embed::{BuiltinConfig, EmbeddedConfig};
+use git_cliff_core::error::{Error, Result};
 use git_cliff_core::release::Release;
 use git_cliff_core::repo::Repository;
-use git_cliff_core::{
-	DEFAULT_CONFIG,
-	IGNORE_FILE,
-};
+use git_cliff_core::{DEFAULT_CONFIG, IGNORE_FILE};
 use std::env;
-use std::fs::{
-	self,
-	File,
-};
+use std::fs::{self, File};
 use std::io;
 use std::path::Path;
-use std::time::{
-	SystemTime,
-	UNIX_EPOCH,
-};
+use std::time::{SystemTime, UNIX_EPOCH};
 
 /// Checks for a new version on crates.io
 #[cfg(feature = "update-informer")]
 fn check_new_version() {
-	use update_informer::Check;
-	let pkg_name = env!("CARGO_PKG_NAME");
-	let pkg_version = env!("CARGO_PKG_VERSION");
-	let informer = update_informer::new(
-		update_informer::registry::Crates,
-		pkg_name,
-		pkg_version,
-	);
-	if let Some(new_version) = informer.check_version().ok().flatten() {
-		if new_version.semver().pre.is_empty() {
-			log::info!(
-				"A new version of {pkg_name} is available: v{pkg_version} -> \
+    use update_informer::Check;
+    let pkg_name = env!("CARGO_PKG_NAME");
+    let pkg_version = env!("CARGO_PKG_VERSION");
+    let informer = update_informer::new(update_informer::registry::Crates, pkg_name, pkg_version);
+    if let Some(new_version) = informer.check_version().ok().flatten() {
+        if new_version.semver().pre.is_empty() {
+            log::info!(
+                "A new version of {pkg_name} is available: v{pkg_version} -> \
 				 {new_version}",
-			);
-		}
-	}
+            );
+        }
+    }
 }
 
 /// Processes the tags and commits for creating release entries for the
@@ -79,554 +52,551 @@ fn check_new_version() {
 /// This function uses the configuration and arguments to process the given
 /// repository individually.
 fn process_repository<'a>(
-	repository: &'static Repository,
-	config: &mut Config,
-	args: &Opt,
+    repository: &'static Repository,
+    config: &mut Config,
+    args: &Opt,
 ) -> Result<Vec<Release<'a>>> {
-	let mut tags = repository.tags(
-		&config.git.tag_pattern,
-		args.topo_order,
-		args.use_branch_tags,
-	)?;
-	let skip_regex = config.git.skip_tags.as_ref();
-	let ignore_regex = config.git.ignore_tags.as_ref();
-	let count_tags = config.git.count_tags.as_ref();
-	tags.retain(|_, tag| {
-		let name = &tag.name;
-
-		// Keep skip tags to drop commits in the later stage.
-		let skip = skip_regex.is_some_and(|r| r.is_match(name));
-		if skip {
-			return true;
-		}
-
-		let count = count_tags.map_or(true, |r| {
-			let count_tag = r.is_match(name);
-			if count_tag {
-				trace!("Counting release: {}", name);
-			}
-			count_tag
-		});
-
-		let ignore = ignore_regex.is_some_and(|r| {
-			if r.as_str().trim().is_empty() {
-				return false;
-			}
-
-			let ignore_tag = r.is_match(name);
-			if ignore_tag {
-				trace!("Ignoring release: {}", name);
-			}
-			ignore_tag
-		});
-
-		count && !ignore
-	});
-
-	if !config.remote.is_any_set() {
-		match repository.upstream_remote() {
-			Ok(remote) => {
-				if !config.remote.github.is_set() {
-					debug!("No GitHub remote is set, using remote: {}", remote);
-					config.remote.github.owner = remote.owner;
-					config.remote.github.repo = remote.repo;
-					config.remote.github.is_custom = remote.is_custom;
-				} else if !config.remote.gitlab.is_set() {
-					debug!("No GitLab remote is set, using remote: {}", remote);
-					config.remote.gitlab.owner = remote.owner;
-					config.remote.gitlab.repo = remote.repo;
-					config.remote.gitlab.is_custom = remote.is_custom;
-				} else if !config.remote.gitea.is_set() {
-					debug!("No Gitea remote is set, using remote: {}", remote);
-					config.remote.gitea.owner = remote.owner;
-					config.remote.gitea.repo = remote.repo;
-					config.remote.gitea.is_custom = remote.is_custom;
-				} else if !config.remote.bitbucket.is_set() {
-					debug!("No Bitbucket remote is set, using remote: {}", remote);
-					config.remote.bitbucket.owner = remote.owner;
-					config.remote.bitbucket.repo = remote.repo;
-					config.remote.bitbucket.is_custom = remote.is_custom;
-				}
-			}
-			Err(e) => {
-				debug!("Failed to get remote from repository: {:?}", e);
-			}
-		}
-	}
-
-	// Print debug information about configuration and arguments.
-	log::trace!("Arguments: {:#?}", args);
-	log::trace!("Config: {:#?}", config);
-
-	// Parse commits.
-	let mut commit_range = args.range.clone();
-	if args.unreleased {
-		if let Some(last_tag) = tags.last().map(|(k, _)| k) {
-			commit_range = Some(format!("{last_tag}..HEAD"));
-		}
-	} else if args.latest || args.current {
-		if tags.len() < 2 {
-			let commits = repository.commits(None, None, None)?;
-			if let (Some(tag1), Some(tag2)) = (
-				commits.last().map(|c| c.id().to_string()),
-				tags.get_index(0).map(|(k, _)| k),
-			) {
-				commit_range = Some(format!("{tag1}..{tag2}"));
-			}
-		} else {
-			let mut tag_index = tags.len() - 2;
-			if args.current {
-				if let Some(current_tag_index) =
-					repository.current_tag().as_ref().and_then(|tag| {
-						tags.iter()
-							.enumerate()
-							.find(|(_, (_, v))| v.name == tag.name)
-							.map(|(i, _)| i)
-					}) {
-					match current_tag_index.checked_sub(1) {
-						Some(i) => tag_index = i,
-						None => {
-							return Err(Error::ChangelogError(String::from(
-								"No suitable tags found. Maybe run with \
+    let mut tags = repository.tags(
+        &config.git.tag_pattern,
+        args.topo_order,
+        args.use_branch_tags,
+    )?;
+    let skip_regex = config.git.skip_tags.as_ref();
+    let ignore_regex = config.git.ignore_tags.as_ref();
+    let count_tags = config.git.count_tags.as_ref();
+    tags.retain(|_, tag| {
+        let name = &tag.name;
+
+        // Keep skip tags to drop commits in the later stage.
+        let skip = skip_regex.is_some_and(|r| r.is_match(name));
+        if skip {
+            return true;
+        }
+
+        let count = count_tags.map_or(true, |r| {
+            let count_tag = r.is_match(name);
+            if count_tag {
+                trace!("Counting release: {}", name);
+            }
+            count_tag
+        });
+
+        let ignore = ignore_regex.is_some_and(|r| {
+            if r.as_str().trim().is_empty() {
+                return false;
+            }
+
+            let ignore_tag = r.is_match(name);
+            if ignore_tag {
+                trace!("Ignoring release: {}", name);
+            }
+            ignore_tag
+        });
+
+        count && !ignore
+    });
+
+    if !config.remote.is_any_set() {
+        match repository.upstream_remote() {
+            Ok(remote) => {
+                if !config.remote.github.is_set() {
+                    debug!("No GitHub remote is set, using remote: {}", remote);
+                    config.remote.github.owner = remote.owner;
+                    config.remote.github.repo = remote.repo;
+                    config.remote.github.is_custom = remote.is_custom;
+                } else if !config.remote.gitlab.is_set() {
+                    debug!("No GitLab remote is set, using remote: {}", remote);
+                    config.remote.gitlab.owner = remote.owner;
+                    config.remote.gitlab.repo = remote.repo;
+                    config.remote.gitlab.is_custom = remote.is_custom;
+                } else if !config.remote.gitea.is_set() {
+                    debug!("No Gitea remote is set, using remote: {}", remote);
+                    config.remote.gitea.owner = remote.owner;
+                    config.remote.gitea.repo = remote.repo;
+                    config.remote.gitea.is_custom = remote.is_custom;
+                } else if !config.remote.bitbucket.is_set() {
+                    debug!("No Bitbucket remote is set, using remote: {}", remote);
+                    config.remote.bitbucket.owner = remote.owner;
+                    config.remote.bitbucket.repo = remote.repo;
+                    config.remote.bitbucket.is_custom = remote.is_custom;
+                }
+            }
+            Err(e) => {
+                debug!("Failed to get remote from repository: {:?}", e);
+            }
+        }
+    }
+
+    // Print debug information about configuration and arguments.
+    log::trace!("Arguments: {:#?}", args);
+    log::trace!("Config: {:#?}", config);
+
+    // Parse commits.
+    let mut commit_range = args.range.clone();
+    if args.unreleased {
+        if let Some(last_tag) = tags.last().map(|(k, _)| k) {
+            commit_range = Some(format!("{last_tag}..HEAD"));
+        }
+    } else if args.latest || args.current {
+        if tags.len() < 2 {
+            let commits = repository.commits(None, None, None)?;
+            if let (Some(tag1), Some(tag2)) = (
+                commits.last().map(|c| c.id().to_string()),
+                tags.get_index(0).map(|(k, _)| k),
+            ) {
+                commit_range = Some(format!("{tag1}..{tag2}"));
+            }
+        } else {
+            let mut tag_index = tags.len() - 2;
+            if args.current {
+                if let Some(current_tag_index) = repository.current_tag().as_ref().and_then(|tag| {
+                    tags.iter()
+                        .enumerate()
+                        .find(|(_, (_, v))| v.name == tag.name)
+                        .map(|(i, _)| i)
+                }) {
+                    match current_tag_index.checked_sub(1) {
+                        Some(i) => tag_index = i,
+                        None => {
+                            return Err(Error::ChangelogError(String::from(
+                                "No suitable tags found. Maybe run with \
 								 '--topo-order'?",
-							)));
-						}
-					}
-				} else {
-					return Err(Error::ChangelogError(String::from(
-						"No tag exists for the current commit",
-					)));
-				}
-			}
-			if let (Some(tag1), Some(tag2)) = (
-				tags.get_index(tag_index).map(|(k, _)| k),
-				tags.get_index(tag_index + 1).map(|(k, _)| k),
-			) {
-				commit_range = Some(format!("{tag1}..{tag2}"));
-			}
-		}
-	}
-	let mut commits = repository.commits(
-		commit_range.as_deref(),
-		args.include_path.clone(),
-		args.exclude_path.clone(),
-	)?;
-	if let Some(commit_limit_value) = config.git.limit_commits {
-		commits.truncate(commit_limit_value);
-	}
-
-	// Update tags.
-	let mut releases = vec![Release::default()];
-	let mut tag_timestamp = None;
-	if let Some(ref tag) = args.tag {
-		if let Some(commit_id) = commits.first().map(|c| c.id().to_string()) {
-			match tags.get(&commit_id) {
-				Some(tag) => {
-					warn!("There is already a tag ({}) for {}", tag.name, commit_id);
-					tag_timestamp = Some(commits[0].time().seconds());
-				}
-				None => {
-					tags.insert(commit_id, repository.resolve_tag(tag));
-				}
-			}
-		} else {
-			releases[0].version = Some(tag.to_string());
-			releases[0].timestamp = SystemTime::now()
-				.duration_since(UNIX_EPOCH)?
-				.as_secs()
-				.try_into()?;
-		}
-	}
-
-	// Process releases.
-	let mut previous_release = Release::default();
-	let mut first_processed_tag = None;
-	for git_commit in commits.iter().rev() {
-		let release = releases.last_mut().unwrap();
-		let commit = Commit::from(git_commit);
-		let commit_id = commit.id.to_string();
-		release.commits.push(commit);
-		release.repository = Some(repository.path.to_string_lossy().into_owned());
-		if let Some(tag) = tags.get(&commit_id) {
-			release.version = Some(tag.name.to_string());
-			release.message.clone_from(&tag.message);
-			release.commit_id = Some(commit_id);
-			release.timestamp = if args.tag.as_deref() == Some(tag.name.as_str()) {
-				match tag_timestamp {
-					Some(timestamp) => timestamp,
-					None => SystemTime::now()
-						.duration_since(UNIX_EPOCH)?
-						.as_secs()
-						.try_into()?,
-				}
-			} else {
-				git_commit.time().seconds()
-			};
-			if first_processed_tag.is_none() {
-				first_processed_tag = Some(tag);
-			}
-			previous_release.previous = None;
-			release.previous = Some(Box::new(previous_release));
-			previous_release = release.clone();
-			releases.push(Release::default());
-		}
-	}
-
-	debug_assert!(!releases.is_empty());
-
-	if releases.len() > 1 {
-		previous_release.previous = None;
-		releases.last_mut().unwrap().previous = Some(Box::new(previous_release));
-	}
-
-	if args.sort == Sort::Newest {
-		for release in &mut releases {
-			release.commits.reverse();
-		}
-	}
-
-	// Add custom commit messages to the latest release.
-	if let Some(custom_commits) = &args.with_commit {
-		releases
-			.last_mut()
-			.unwrap()
-			.commits
-			.extend(custom_commits.iter().cloned().map(Commit::from));
-	}
-
-	// Set the previous release if the first release does not have one set.
-	if releases[0]
-		.previous
-		.as_ref()
-		.and_then(|p| p.version.as_ref())
-		.is_none()
-	{
-		// Get the previous tag of the first processed tag in the release loop.
-		let first_tag = first_processed_tag
-			.map(|tag| {
-				tags.iter()
-					.enumerate()
-					.find(|(_, (_, v))| v.name == tag.name)
-					.and_then(|(i, _)| i.checked_sub(1))
-					.and_then(|i| tags.get_index(i))
-			})
-			.or_else(|| Some(tags.last()))
-			.flatten();
-
-		// Set the previous release if the first tag is found.
-		if let Some((commit_id, tag)) = first_tag {
-			let previous_release = Release {
-				commit_id: Some(commit_id.to_string()),
-				version: Some(tag.name.clone()),
-				timestamp: repository
-					.find_commit(commit_id)
-					.map(|v| v.time().seconds())
-					.unwrap_or_default(),
-				..Default::default()
-			};
-			releases[0].previous = Some(Box::new(previous_release));
-		}
-	}
-
-	// Set custom message for the latest release.
-	if let Some(message) = &args.with_tag_message {
-		if let Some(latest_release) = releases
-			.iter_mut()
-			.filter(|release| !release.commits.is_empty())
-			.last()
-		{
-			latest_release.message = Some(message.to_owned());
-		}
-	}
-
-	Ok(releases)
+                            )));
+                        }
+                    }
+                } else {
+                    return Err(Error::ChangelogError(String::from(
+                        "No tag exists for the current commit",
+                    )));
+                }
+            }
+            if let (Some(tag1), Some(tag2)) = (
+                tags.get_index(tag_index).map(|(k, _)| k),
+                tags.get_index(tag_index + 1).map(|(k, _)| k),
+            ) {
+                commit_range = Some(format!("{tag1}..{tag2}"));
+            }
+        }
+    }
+    let mut commits = repository.commits(
+        commit_range.as_deref(),
+        args.include_path.clone(),
+        args.exclude_path.clone(),
+    )?;
+    if let Some(commit_limit_value) = config.git.limit_commits {
+        commits.truncate(commit_limit_value);
+    }
+
+    // Update tags.
+    let mut releases = vec![Release::default()];
+    let mut tag_timestamp = None;
+    if let Some(ref tag) = args.tag {
+        if let Some(commit_id) = commits.first().map(|c| c.id().to_string()) {
+            match tags.get(&commit_id) {
+                Some(tag) => {
+                    warn!("There is already a tag ({}) for {}", tag.name, commit_id);
+                    tag_timestamp = Some(commits[0].time().seconds());
+                }
+                None => {
+                    tags.insert(commit_id, repository.resolve_tag(tag));
+                }
+            }
+        } else {
+            releases[0].version = Some(tag.to_string());
+            releases[0].timestamp = SystemTime::now()
+                .duration_since(UNIX_EPOCH)?
+                .as_secs()
+                .try_into()?;
+        }
+    }
+
+    // Process releases.
+    let mut previous_release = Release::default();
+    let mut first_processed_tag = None;
+    for git_commit in commits.iter().rev() {
+        let release = releases.last_mut().unwrap();
+        let commit = Commit::from(git_commit);
+        let commit_id = commit.id.to_string();
+        release.commits.push(commit);
+        release.repository = Some(repository.path.to_string_lossy().into_owned());
+        if let Some(tag) = tags.get(&commit_id) {
+            release.version = Some(tag.name.to_string());
+            release.message.clone_from(&tag.message);
+            release.commit_id = Some(commit_id);
+            release.timestamp = if args.tag.as_deref() == Some(tag.name.as_str()) {
+                match tag_timestamp {
+                    Some(timestamp) => timestamp,
+                    None => SystemTime::now()
+                        .duration_since(UNIX_EPOCH)?
+                        .as_secs()
+                        .try_into()?,
+                }
+            } else {
+                git_commit.time().seconds()
+            };
+            if first_processed_tag.is_none() {
+                first_processed_tag = Some(tag);
+            }
+            previous_release.previous = None;
+            release.previous = Some(Box::new(previous_release));
+            previous_release = release.clone();
+            releases.push(Release::default());
+        }
+    }
+
+    debug_assert!(!releases.is_empty());
+
+    if releases.len() > 1 {
+        previous_release.previous = None;
+        releases.last_mut().unwrap().previous = Some(Box::new(previous_release));
+    }
+
+    if args.sort == Sort::Newest {
+        for release in &mut releases {
+            release.commits.reverse();
+        }
+    }
+
+    // Add custom commit messages to the latest release.
+    if let Some(custom_commits) = &args.with_commit {
+        releases
+            .last_mut()
+            .unwrap()
+            .commits
+            .extend(custom_commits.iter().cloned().map(Commit::from));
+    }
+
+    // Set the previous release if the first release does not have one set.
+    if releases[0]
+        .previous
+        .as_ref()
+        .and_then(|p| p.version.as_ref())
+        .is_none()
+    {
+        // Get the previous tag of the first processed tag in the release loop.
+        let first_tag = first_processed_tag
+            .map(|tag| {
+                tags.iter()
+                    .enumerate()
+                    .find(|(_, (_, v))| v.name == tag.name)
+                    .and_then(|(i, _)| i.checked_sub(1))
+                    .and_then(|i| tags.get_index(i))
+            })
+            .or_else(|| Some(tags.last()))
+            .flatten();
+
+        // Set the previous release if the first tag is found.
+        if let Some((commit_id, tag)) = first_tag {
+            let previous_release = Release {
+                commit_id: Some(commit_id.to_string()),
+                version: Some(tag.name.clone()),
+                timestamp: repository
+                    .find_commit(commit_id)
+                    .map(|v| v.time().seconds())
+                    .unwrap_or_default(),
+                ..Default::default()
+            };
+            releases[0].previous = Some(Box::new(previous_release));
+        }
+    }
+
+    // Set custom message for the latest release.
+    if let Some(message) = &args.with_tag_message {
+        if let Some(latest_release) = releases
+            .iter_mut()
+            .filter(|release| !release.commits.is_empty())
+            .last()
+        {
+            latest_release.message = Some(message.to_owned());
+        }
+    }
+
+    Ok(releases)
 }
 
 /// Runs `git-cliff`.
 pub fn run(mut args: Opt) -> Result<()> {
-	// Check if there is a new version available.
-	#[cfg(feature = "update-informer")]
-	check_new_version();
-
-	// Create the configuration file if init flag is given.
-	if let Some(init_config) = args.init {
-		let contents = match init_config {
-			Some(ref name) => BuiltinConfig::get_config(name.to_string())?,
-			None => EmbeddedConfig::get_config()?,
-		};
-		info!(
-			"Saving the configuration file{} to {:?}",
-			init_config.map(|v| format!(" ({v})")).unwrap_or_default(),
-			DEFAULT_CONFIG
-		);
-		fs::write(DEFAULT_CONFIG, contents)?;
-		return Ok(());
-	}
-
-	// Retrieve the built-in configuration.
-	let builtin_config =
-		BuiltinConfig::parse(args.config.to_string_lossy().to_string());
-
-	// Set the working directory.
-	if let Some(ref workdir) = args.workdir {
-		args.config = workdir.join(args.config);
-		match args.repository.as_mut() {
-			Some(repository) => {
-				repository
-					.iter_mut()
-					.for_each(|r| *r = workdir.join(r.clone()));
-			}
-			None => args.repository = Some(vec![workdir.clone()]),
-		}
-		if let Some(changelog) = args.prepend {
-			args.prepend = Some(workdir.join(changelog));
-		}
-	}
-
-	// Parse the configuration file.
-	let mut path = args.config.clone();
-	if !path.exists() {
-		if let Some(config_path) = dirs::config_dir()
-			.map(|dir| dir.join(env!("CARGO_PKG_NAME")).join(DEFAULT_CONFIG))
-		{
-			path = config_path;
-		}
-	}
-
-	// Load the default configuration if necessary.
-	let mut config = if let Ok((config, name)) = builtin_config {
-		info!("Using built-in configuration file: {name}");
-		config
-	} else if path.exists() {
-		Config::parse(&path)?
-	} else if let Some(contents) = Config::read_from_manifest()? {
-		Config::parse_from_str(&contents)?
-	} else {
-		if !args.context {
-			warn!(
-				"{:?} is not found, using the default configuration.",
-				args.config
-			);
-		}
-		EmbeddedConfig::parse()?
-	};
-	if config.changelog.body.is_none() && !args.context && !args.bumped_version {
-		warn!("Changelog body is not specified, using the default template.");
-		config.changelog.body = EmbeddedConfig::parse()?.changelog.body;
-	}
-
-	// Update the configuration based on command line arguments and vice versa.
-	let output = args.output.clone().or(config.changelog.output.clone());
-	match args.strip {
-		Some(Strip::Header) => {
-			config.changelog.header = None;
-		}
-		Some(Strip::Footer) => {
-			config.changelog.footer = None;
-		}
-		Some(Strip::All) => {
-			config.changelog.header = None;
-			config.changelog.footer = None;
-		}
-		None => {}
-	}
-	if args.prepend.is_some() {
-		config.changelog.footer = None;
-		if !(args.unreleased || args.latest || args.range.is_some()) {
-			return Err(Error::ArgumentError(String::from(
-				"'-u' or '-l' is not specified",
-			)));
-		}
-	}
-	if output.is_some() &&
-		args.prepend.is_some() &&
-		output.as_ref() == args.prepend.as_ref()
-	{
-		return Err(Error::ArgumentError(String::from(
-			"'-o' and '-p' can only be used together if they point to different \
+    // Check if there is a new version available.
+    #[cfg(feature = "update-informer")]
+    check_new_version();
+
+    // Create the configuration file if init flag is given.
+    if let Some(init_config) = args.init {
+        let contents = match init_config {
+            Some(ref name) => BuiltinConfig::get_config(name.to_string())?,
+            None => EmbeddedConfig::get_config()?,
+        };
+        info!(
+            "Saving the configuration file{} to {:?}",
+            init_config.map(|v| format!(" ({v})")).unwrap_or_default(),
+            DEFAULT_CONFIG
+        );
+        fs::write(DEFAULT_CONFIG, contents)?;
+        return Ok(());
+    }
+
+    // Retrieve the built-in configuration.
+    let builtin_config = BuiltinConfig::parse(args.config.to_string_lossy().to_string());
+
+    // Set the working directory.
+    if let Some(ref workdir) = args.workdir {
+        args.config = workdir.join(args.config);
+        match args.repository.as_mut() {
+            Some(repository) => {
+                repository
+                    .iter_mut()
+                    .for_each(|r| *r = workdir.join(r.clone()));
+            }
+            None => args.repository = Some(vec![workdir.clone()]),
+        }
+        if let Some(changelog) = args.prepend {
+            args.prepend = Some(workdir.join(changelog));
+        }
+    }
+
+    // Parse the configuration file.
+    let mut path = args.config.clone();
+    if !path.exists() {
+        if let Some(config_path) =
+            dirs::config_dir().map(|dir| dir.join(env!("CARGO_PKG_NAME")).join(DEFAULT_CONFIG))
+        {
+            path = config_path;
+        }
+    }
+
+    // Load the default configuration if necessary.
+    let mut config = if let Ok((config, name)) = builtin_config {
+        info!("Using built-in configuration file: {name}");
+        config
+    } else if path.exists() {
+        Config::parse(&path)?
+    } else if let Some(contents) = Config::read_from_manifest()? {
+        Config::parse_from_str(&contents)?
+    } else {
+        if !args.context {
+            warn!(
+                "{:?} is not found, using the default configuration.",
+                args.config
+            );
+        }
+        EmbeddedConfig::parse()?
+    };
+    if config.changelog.body.is_none() && !args.context && !args.bumped_version {
+        warn!("Changelog body is not specified, using the default template.");
+        config.changelog.body = EmbeddedConfig::parse()?.changelog.body;
+    }
+
+    // Update the configuration based on command line arguments and vice versa.
+    let output = args.output.clone().or(config.changelog.output.clone());
+    match args.strip {
+        Some(Strip::Header) => {
+            config.changelog.header = None;
+        }
+        Some(Strip::Footer) => {
+            config.changelog.footer = None;
+        }
+        Some(Strip::All) => {
+            config.changelog.header = None;
+            config.changelog.footer = None;
+        }
+        None => {}
+    }
+    if args.prepend.is_some() {
+        config.changelog.footer = None;
+        if !(args.unreleased || args.latest || args.range.is_some()) {
+            return Err(Error::ArgumentError(String::from(
+                "'-u' or '-l' is not specified",
+            )));
+        }
+    }
+    if output.is_some() && args.prepend.is_some() && output.as_ref() == args.prepend.as_ref() {
+        return Err(Error::ArgumentError(String::from(
+            "'-o' and '-p' can only be used together if they point to different \
 			 files",
-		)));
-	}
-	if args.body.is_some() {
-		config.changelog.body.clone_from(&args.body);
-	}
-	if args.sort == Sort::Oldest {
-		if let Some(ref sort_commits) = config.git.sort_commits {
-			args.sort = Sort::from_str(sort_commits, true)
-				.expect("Incorrect config value for 'sort_commits'");
-		}
-	}
-	if !args.topo_order {
-		if let Some(topo_order) = config.git.topo_order {
-			args.topo_order = topo_order;
-		}
-	}
-
-	if !args.use_branch_tags {
-		if let Some(use_branch_tags) = config.git.use_branch_tags {
-			args.use_branch_tags = use_branch_tags;
-		}
-	}
-
-	if args.github_token.is_some() {
-		config.remote.github.token.clone_from(&args.github_token);
-	}
-	if args.gitlab_token.is_some() {
-		config.remote.gitlab.token.clone_from(&args.gitlab_token);
-	}
-	if args.gitea_token.is_some() {
-		config.remote.gitea.token.clone_from(&args.gitea_token);
-	}
-	if args.bitbucket_token.is_some() {
-		config
-			.remote
-			.bitbucket
-			.token
-			.clone_from(&args.bitbucket_token);
-	}
-	if let Some(ref remote) = args.github_repo {
-		config.remote.github.owner = remote.0.owner.to_string();
-		config.remote.github.repo = remote.0.repo.to_string();
-		config.remote.github.is_custom = true;
-	}
-	if let Some(ref remote) = args.gitlab_repo {
-		config.remote.gitlab.owner = remote.0.owner.to_string();
-		config.remote.gitlab.repo = remote.0.repo.to_string();
-		config.remote.gitlab.is_custom = true;
-	}
-	if let Some(ref remote) = args.bitbucket_repo {
-		config.remote.bitbucket.owner = remote.0.owner.to_string();
-		config.remote.bitbucket.repo = remote.0.repo.to_string();
-		config.remote.bitbucket.is_custom = true;
-	}
-	if let Some(ref remote) = args.gitea_repo {
-		config.remote.gitea.owner = remote.0.owner.to_string();
-		config.remote.gitea.repo = remote.0.repo.to_string();
-		config.remote.gitea.is_custom = true;
-	}
-	if args.no_exec {
-		if let Some(ref mut preprocessors) = config.git.commit_preprocessors {
-			preprocessors
-				.iter_mut()
-				.for_each(|v| v.replace_command = None);
-		}
-		if let Some(ref mut postprocessors) = config.changelog.postprocessors {
-			postprocessors
-				.iter_mut()
-				.for_each(|v| v.replace_command = None);
-		}
-	}
-	config.git.skip_tags = config.git.skip_tags.filter(|r| !r.as_str().is_empty());
-	if args.tag_pattern.is_some() {
-		config.git.tag_pattern.clone_from(&args.tag_pattern);
-	}
-	if args.tag.is_some() {
-		config.bump.initial_tag.clone_from(&args.tag);
-	}
-	if args.ignore_tags.is_some() {
-		config.git.ignore_tags.clone_from(&args.ignore_tags);
-	}
-	if args.count_tags.is_some() {
-		config.git.count_tags.clone_from(&args.count_tags);
-	}
-
-	// Process commits and releases for the changelog.
-	if let Some(BumpOption::Specific(bump_type)) = args.bump {
-		config.bump.bump_type = Some(bump_type);
-	}
-
-	// Generate changelog from context.
-	let mut changelog: Changelog = if let Some(context_path) = args.from_context {
-		let mut input: Box<dyn io::Read> = if context_path == Path::new("-") {
-			Box::new(io::stdin())
-		} else {
-			Box::new(File::open(context_path)?)
-		};
-		let mut changelog = Changelog::from_context(&mut input, &config)?;
-		changelog.add_remote_context()?;
-		changelog
-	} else {
-		// Process the repositories.
-		let repositories =
-			args.repository.clone().unwrap_or(vec![env::current_dir()?]);
-		let mut releases = Vec::<Release>::new();
-		for repository in repositories {
-			// Skip commits
-			let mut skip_list = Vec::new();
-			let ignore_file = repository.join(IGNORE_FILE);
-			if ignore_file.exists() {
-				let contents = fs::read_to_string(ignore_file)?;
-				let commits = contents
-					.lines()
-					.filter(|v| !(v.starts_with('#') || v.trim().is_empty()))
-					.map(|v| String::from(v.trim()))
-					.collect::<Vec<String>>();
-				skip_list.extend(commits);
-			}
-			if let Some(ref skip_commit) = args.skip_commit {
-				skip_list.extend(skip_commit.clone());
-			}
-			if let Some(commit_parsers) = config.git.commit_parsers.as_mut() {
-				for sha1 in skip_list {
-					commit_parsers.insert(0, CommitParser {
-						sha: Some(sha1.to_string()),
-						skip: Some(true),
-						..Default::default()
-					});
-				}
-			}
-
-			// Process the repository.
-			let repository = Repository::init(repository)?;
-			releases.extend(process_repository(
-				Box::leak(Box::new(repository)),
-				&mut config,
-				&args,
-			)?);
-		}
-		Changelog::new(releases, &config)?
-	};
-
-	// Print the result.
-	let mut out: Box<dyn io::Write> = if let Some(path) = &output {
-		if path == Path::new("-") {
-			Box::new(io::stdout())
-		} else {
-			Box::new(io::BufWriter::new(File::create(path)?))
-		}
-	} else {
-		Box::new(io::stdout())
-	};
-	if args.bump.is_some() || args.bumped_version {
-		let next_version = if let Some(next_version) = changelog.bump_version()? {
-			next_version
-		} else if let Some(last_version) =
-			changelog.releases.first().cloned().and_then(|v| v.version)
-		{
-			warn!("There is nothing to bump.");
-			last_version
-		} else if changelog.releases.is_empty() {
-			config.bump.get_initial_tag()
-		} else {
-			return Ok(());
-		};
-		if args.bumped_version {
-			writeln!(out, "{next_version}")?;
-			return Ok(());
-		}
-	}
-	if args.context {
-		changelog.write_context(&mut out)?;
-		return Ok(());
-	}
-	if let Some(path) = &args.prepend {
-		let changelog_before = fs::read_to_string(path)?;
-		let mut out = io::BufWriter::new(File::create(path)?);
-		changelog.prepend(changelog_before, &mut out)?;
-	}
-	if output.is_some() || args.prepend.is_none() {
-		changelog.generate(&mut out)?;
-	}
-
-	Ok(())
+        )));
+    }
+    if args.body.is_some() {
+        config.changelog.body.clone_from(&args.body);
+    }
+    if args.sort == Sort::Oldest {
+        if let Some(ref sort_commits) = config.git.sort_commits {
+            args.sort = Sort::from_str(sort_commits, true)
+                .expect("Incorrect config value for 'sort_commits'");
+        }
+    }
+    if !args.topo_order {
+        if let Some(topo_order) = config.git.topo_order {
+            args.topo_order = topo_order;
+        }
+    }
+
+    if !args.use_branch_tags {
+        if let Some(use_branch_tags) = config.git.use_branch_tags {
+            args.use_branch_tags = use_branch_tags;
+        }
+    }
+
+    if args.github_token.is_some() {
+        config.remote.github.token.clone_from(&args.github_token);
+    }
+    if args.gitlab_token.is_some() {
+        config.remote.gitlab.token.clone_from(&args.gitlab_token);
+    }
+    if args.gitea_token.is_some() {
+        config.remote.gitea.token.clone_from(&args.gitea_token);
+    }
+    if args.bitbucket_token.is_some() {
+        config
+            .remote
+            .bitbucket
+            .token
+            .clone_from(&args.bitbucket_token);
+    }
+    if let Some(ref remote) = args.github_repo {
+        config.remote.github.owner = remote.0.owner.to_string();
+        config.remote.github.repo = remote.0.repo.to_string();
+        config.remote.github.is_custom = true;
+    }
+    if let Some(ref remote) = args.gitlab_repo {
+        config.remote.gitlab.owner = remote.0.owner.to_string();
+        config.remote.gitlab.repo = remote.0.repo.to_string();
+        config.remote.gitlab.is_custom = true;
+    }
+    if let Some(ref remote) = args.bitbucket_repo {
+        config.remote.bitbucket.owner = remote.0.owner.to_string();
+        config.remote.bitbucket.repo = remote.0.repo.to_string();
+        config.remote.bitbucket.is_custom = true;
+    }
+    if let Some(ref remote) = args.gitea_repo {
+        config.remote.gitea.owner = remote.0.owner.to_string();
+        config.remote.gitea.repo = remote.0.repo.to_string();
+        config.remote.gitea.is_custom = true;
+    }
+    if args.no_exec {
+        if let Some(ref mut preprocessors) = config.git.commit_preprocessors {
+            preprocessors
+                .iter_mut()
+                .for_each(|v| v.replace_command = None);
+        }
+        if let Some(ref mut postprocessors) = config.changelog.postprocessors {
+            postprocessors
+                .iter_mut()
+                .for_each(|v| v.replace_command = None);
+        }
+    }
+    config.git.skip_tags = config.git.skip_tags.filter(|r| !r.as_str().is_empty());
+    if args.tag_pattern.is_some() {
+        config.git.tag_pattern.clone_from(&args.tag_pattern);
+    }
+    if args.tag.is_some() {
+        config.bump.initial_tag.clone_from(&args.tag);
+    }
+    if args.ignore_tags.is_some() {
+        config.git.ignore_tags.clone_from(&args.ignore_tags);
+    }
+    if args.count_tags.is_some() {
+        config.git.count_tags.clone_from(&args.count_tags);
+    }
+
+    // Process commits and releases for the changelog.
+    if let Some(BumpOption::Specific(bump_type)) = args.bump {
+        config.bump.bump_type = Some(bump_type);
+    }
+
+    // Generate changelog from context.
+    let mut changelog: Changelog = if let Some(context_path) = args.from_context {
+        let mut input: Box<dyn io::Read> = if context_path == Path::new("-") {
+            Box::new(io::stdin())
+        } else {
+            Box::new(File::open(context_path)?)
+        };
+        let mut changelog = Changelog::from_context(&mut input, &config)?;
+        changelog.add_remote_context()?;
+        changelog
+    } else {
+        // Process the repositories.
+        let repositories = args.repository.clone().unwrap_or(vec![env::current_dir()?]);
+        let mut releases = Vec::<Release>::new();
+        for repository in repositories {
+            // Skip commits
+            let mut skip_list = Vec::new();
+            let ignore_file = repository.join(IGNORE_FILE);
+            if ignore_file.exists() {
+                let contents = fs::read_to_string(ignore_file)?;
+                let commits = contents
+                    .lines()
+                    .filter(|v| !(v.starts_with('#') || v.trim().is_empty()))
+                    .map(|v| String::from(v.trim()))
+                    .collect::<Vec<String>>();
+                skip_list.extend(commits);
+            }
+            if let Some(ref skip_commit) = args.skip_commit {
+                skip_list.extend(skip_commit.clone());
+            }
+            if let Some(commit_parsers) = config.git.commit_parsers.as_mut() {
+                for sha1 in skip_list {
+                    commit_parsers.insert(
+                        0,
+                        CommitParser {
+                            sha: Some(sha1.to_string()),
+                            skip: Some(true),
+                            ..Default::default()
+                        },
+                    );
+                }
+            }
+
+            // Process the repository.
+            let repository = Repository::init(repository)?;
+            releases.extend(process_repository(
+                Box::leak(Box::new(repository)),
+                &mut config,
+                &args,
+            )?);
+        }
+        Changelog::new(releases, &config)?
+    };
+
+    // Print the result.
+    let mut out: Box<dyn io::Write> = if let Some(path) = &output {
+        if path == Path::new("-") {
+            Box::new(io::stdout())
+        } else {
+            Box::new(io::BufWriter::new(File::create(path)?))
+        }
+    } else {
+        Box::new(io::stdout())
+    };
+    if args.bump.is_some() || args.bumped_version {
+        let next_version = if let Some(next_version) = changelog.bump_version()? {
+            next_version
+        } else if let Some(last_version) =
+            changelog.releases.first().cloned().and_then(|v| v.version)
+        {
+            warn!("There is nothing to bump.");
+            last_version
+        } else if changelog.releases.is_empty() {
+            config.bump.get_initial_tag()
+        } else {
+            return Ok(());
+        };
+        if args.bumped_version {
+            writeln!(out, "{next_version}")?;
+            return Ok(());
+        }
+    }
+    if args.context {
+        changelog.write_context(&mut out)?;
+        return Ok(());
+    }
+    if let Some(path) = &args.prepend {
+        let changelog_before = fs::read_to_string(path)?;
+        let mut out = io::BufWriter::new(File::create(path)?);
+        changelog.prepend(changelog_before, &mut out)?;
+    }
+    if output.is_some() || args.prepend.is_none() {
+        changelog.generate(&mut out)?;
+    }
+
+    Ok(())
 }
diff --git a/git-cliff/src/logger.rs b/git-cliff/src/logger.rs
index 17e80d399f..40a556685e 100644
--- a/git-cliff/src/logger.rs
+++ b/git-cliff/src/logger.rs
@@ -1,30 +1,14 @@
 use env_logger::{
-	fmt::{
-		Color,
-		Style,
-		StyledValue,
-	},
-	Builder,
-};
-use git_cliff_core::error::{
-	Error,
-	Result,
+    fmt::{Color, Style, StyledValue},
+    Builder,
 };
+use git_cliff_core::error::{Error, Result};
 #[cfg(feature = "remote")]
-use indicatif::{
-	ProgressBar,
-	ProgressStyle,
-};
+use indicatif::{ProgressBar, ProgressStyle};
 use log::Level;
 use std::io::Write;
-use std::sync::atomic::{
-	AtomicUsize,
-	Ordering,
-};
-use std::{
-	env,
-	fmt,
-};
+use std::sync::atomic::{AtomicUsize, Ordering};
+use std::{env, fmt};
 
 /// Environment variable to use for the logger.
 const LOGGER_ENV: &str = "RUST_LOG";
@@ -34,58 +18,58 @@ static MAX_MODULE_WIDTH: AtomicUsize = AtomicUsize::new(0);
 
 /// Wrapper for the padded values.
 struct Padded<T> {
-	value: T,
-	width: usize,
+    value: T,
+    width: usize,
 }
 
 impl<T: fmt::Display> fmt::Display for Padded<T> {
-	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-		write!(f, "{: <width$}", self.value, width = self.width)
-	}
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{: <width$}", self.value, width = self.width)
+    }
 }
 
 /// Returns the max width of the target.
 fn max_target_width(target: &str) -> usize {
-	let max_width = MAX_MODULE_WIDTH.load(Ordering::Relaxed);
-	if max_width < target.len() {
-		MAX_MODULE_WIDTH.store(target.len(), Ordering::Relaxed);
-		target.len()
-	} else {
-		max_width
-	}
+    let max_width = MAX_MODULE_WIDTH.load(Ordering::Relaxed);
+    if max_width < target.len() {
+        MAX_MODULE_WIDTH.store(target.len(), Ordering::Relaxed);
+        target.len()
+    } else {
+        max_width
+    }
 }
 
 /// Adds colors to the given level and returns it.
 fn colored_level(style: &mut Style, level: Level) -> StyledValue<'_, &'static str> {
-	match level {
-		Level::Trace => style.set_color(Color::Magenta).value("TRACE"),
-		Level::Debug => style.set_color(Color::Blue).value("DEBUG"),
-		Level::Info => style.set_color(Color::Green).value("INFO "),
-		Level::Warn => style.set_color(Color::Yellow).value("WARN "),
-		Level::Error => style.set_color(Color::Red).value("ERROR"),
-	}
+    match level {
+        Level::Trace => style.set_color(Color::Magenta).value("TRACE"),
+        Level::Debug => style.set_color(Color::Blue).value("DEBUG"),
+        Level::Info => style.set_color(Color::Green).value("INFO "),
+        Level::Warn => style.set_color(Color::Yellow).value("WARN "),
+        Level::Error => style.set_color(Color::Red).value("ERROR"),
+    }
 }
 
 #[cfg(feature = "remote")]
 lazy_static::lazy_static! {
-	/// Lazily initialized progress bar.
-	pub static ref PROGRESS_BAR: ProgressBar = {
-		let progress_bar = ProgressBar::new_spinner();
-		progress_bar.set_style(
-			ProgressStyle::with_template("{spinner:.green} {msg}")
-				.unwrap()
-				.tick_strings(&[
-					"▹▹▹▹▹",
-					"▸▹▹▹▹",
-					"▹▸▹▹▹",
-					"▹▹▸▹▹",
-					"▹▹▹▸▹",
-					"▹▹▹▹▸",
-					"▪▪▪▪▪",
-				]),
-		);
-		progress_bar
-	};
+    /// Lazily initialized progress bar.
+    pub static ref PROGRESS_BAR: ProgressBar = {
+        let progress_bar = ProgressBar::new_spinner();
+        progress_bar.set_style(
+            ProgressStyle::with_template("{spinner:.green} {msg}")
+                .unwrap()
+                .tick_strings(&[
+                    "▹▹▹▹▹",
+                    "▸▹▹▹▹",
+                    "▹▸▹▹▹",
+                    "▹▹▸▹▹",
+                    "▹▹▹▸▹",
+                    "▹▹▹▹▸",
+                    "▪▪▪▪▪",
+                ]),
+        );
+        progress_bar
+    };
 }
 
 /// Initializes the global logger.
@@ -94,99 +78,81 @@ lazy_static::lazy_static! {
 /// by the network operations that are related to GitHub.
 #[allow(unreachable_code, clippy::needless_return)]
 pub fn init() -> Result<()> {
-	let mut builder = Builder::new();
-	builder.format(move |f, record| {
-		let target = record.target();
-		let max_width = max_target_width(target);
-
-		let mut style = f.style();
-		let level = colored_level(&mut style, record.level());
-
-		let mut style = f.style();
-		let target = style.set_bold(true).value(Padded {
-			value: target,
-			width: max_width,
-		});
-
-		#[cfg(feature = "github")]
-		{
-			let message = record.args().to_string();
-			if message
-				.starts_with(git_cliff_core::remote::github::START_FETCHING_MSG)
-			{
-				PROGRESS_BAR
-					.enable_steady_tick(std::time::Duration::from_millis(80));
-				PROGRESS_BAR.set_message(message);
-				return Ok(());
-			} else if message
-				.starts_with(git_cliff_core::remote::github::FINISHED_FETCHING_MSG)
-			{
-				PROGRESS_BAR.finish_and_clear();
-				return Ok(());
-			}
-		}
-
-		#[cfg(feature = "gitlab")]
-		{
-			let message = record.args().to_string();
-			if message
-				.starts_with(git_cliff_core::remote::gitlab::START_FETCHING_MSG)
-			{
-				PROGRESS_BAR
-					.enable_steady_tick(std::time::Duration::from_millis(80));
-				PROGRESS_BAR.set_message(message);
-				return Ok(());
-			} else if message
-				.starts_with(git_cliff_core::remote::gitlab::FINISHED_FETCHING_MSG)
-			{
-				PROGRESS_BAR.finish_and_clear();
-				return Ok(());
-			}
-		}
-
-		#[cfg(feature = "gitea")]
-		{
-			let message = record.args().to_string();
-			if message.starts_with(git_cliff_core::remote::gitea::START_FETCHING_MSG)
-			{
-				PROGRESS_BAR
-					.enable_steady_tick(std::time::Duration::from_millis(80));
-				PROGRESS_BAR.set_message(message);
-				return Ok(());
-			} else if message
-				.starts_with(git_cliff_core::remote::gitea::FINISHED_FETCHING_MSG)
-			{
-				PROGRESS_BAR.finish_and_clear();
-				return Ok(());
-			}
-		}
-
-		#[cfg(feature = "bitbucket")]
-		{
-			let message = record.args().to_string();
-			if message
-				.starts_with(git_cliff_core::remote::bitbucket::START_FETCHING_MSG)
-			{
-				PROGRESS_BAR
-					.enable_steady_tick(std::time::Duration::from_millis(80));
-				PROGRESS_BAR.set_message(message);
-				return Ok(());
-			} else if message.starts_with(
-				git_cliff_core::remote::bitbucket::FINISHED_FETCHING_MSG,
-			) {
-				PROGRESS_BAR.finish_and_clear();
-				return Ok(());
-			}
-		}
-
-		writeln!(f, " {} {} > {}", level, target, record.args())
-	});
-
-	if let Ok(var) = env::var(LOGGER_ENV) {
-		builder.parse_filters(&var);
-	}
-
-	builder
-		.try_init()
-		.map_err(|e| Error::LoggerError(e.to_string()))
+    let mut builder = Builder::new();
+    builder.format(move |f, record| {
+        let target = record.target();
+        let max_width = max_target_width(target);
+
+        let mut style = f.style();
+        let level = colored_level(&mut style, record.level());
+
+        let mut style = f.style();
+        let target = style.set_bold(true).value(Padded {
+            value: target,
+            width: max_width,
+        });
+
+        #[cfg(feature = "github")]
+        {
+            let message = record.args().to_string();
+            if message.starts_with(git_cliff_core::remote::github::START_FETCHING_MSG) {
+                PROGRESS_BAR.enable_steady_tick(std::time::Duration::from_millis(80));
+                PROGRESS_BAR.set_message(message);
+                return Ok(());
+            } else if message.starts_with(git_cliff_core::remote::github::FINISHED_FETCHING_MSG) {
+                PROGRESS_BAR.finish_and_clear();
+                return Ok(());
+            }
+        }
+
+        #[cfg(feature = "gitlab")]
+        {
+            let message = record.args().to_string();
+            if message.starts_with(git_cliff_core::remote::gitlab::START_FETCHING_MSG) {
+                PROGRESS_BAR.enable_steady_tick(std::time::Duration::from_millis(80));
+                PROGRESS_BAR.set_message(message);
+                return Ok(());
+            } else if message.starts_with(git_cliff_core::remote::gitlab::FINISHED_FETCHING_MSG) {
+                PROGRESS_BAR.finish_and_clear();
+                return Ok(());
+            }
+        }
+
+        #[cfg(feature = "gitea")]
+        {
+            let message = record.args().to_string();
+            if message.starts_with(git_cliff_core::remote::gitea::START_FETCHING_MSG) {
+                PROGRESS_BAR.enable_steady_tick(std::time::Duration::from_millis(80));
+                PROGRESS_BAR.set_message(message);
+                return Ok(());
+            } else if message.starts_with(git_cliff_core::remote::gitea::FINISHED_FETCHING_MSG) {
+                PROGRESS_BAR.finish_and_clear();
+                return Ok(());
+            }
+        }
+
+        #[cfg(feature = "bitbucket")]
+        {
+            let message = record.args().to_string();
+            if message.starts_with(git_cliff_core::remote::bitbucket::START_FETCHING_MSG) {
+                PROGRESS_BAR.enable_steady_tick(std::time::Duration::from_millis(80));
+                PROGRESS_BAR.set_message(message);
+                return Ok(());
+            } else if message.starts_with(git_cliff_core::remote::bitbucket::FINISHED_FETCHING_MSG)
+            {
+                PROGRESS_BAR.finish_and_clear();
+                return Ok(());
+            }
+        }
+
+        writeln!(f, " {} {} > {}", level, target, record.args())
+    });
+
+    if let Ok(var) = env::var(LOGGER_ENV) {
+        builder.parse_filters(&var);
+    }
+
+    builder
+        .try_init()
+        .map_err(|e| Error::LoggerError(e.to_string()))
 }
diff --git a/git-cliff/src/main.rs b/git-cliff/src/main.rs
index 90738254e0..77de0b68b6 100644
--- a/git-cliff/src/main.rs
+++ b/git-cliff/src/main.rs
@@ -10,42 +10,42 @@ use std::process;
 mod profiler;
 
 fn main() -> Result<()> {
-	// Parse the command line arguments
-	let args = Opt::parse();
-	if args.verbose == 1 {
-		env::set_var("RUST_LOG", "debug");
-	} else if args.verbose > 1 {
-		env::set_var("RUST_LOG", "trace");
-	} else if env::var_os("RUST_LOG").is_none() {
-		env::set_var("RUST_LOG", "info");
-	}
-	logger::init()?;
+    // Parse the command line arguments
+    let args = Opt::parse();
+    if args.verbose == 1 {
+        env::set_var("RUST_LOG", "debug");
+    } else if args.verbose > 1 {
+        env::set_var("RUST_LOG", "trace");
+    } else if env::var_os("RUST_LOG").is_none() {
+        env::set_var("RUST_LOG", "info");
+    }
+    logger::init()?;
 
-	// Initialize the profiler guard if the feature is enabled
-	let mut _profiler_guard = None;
-	#[cfg(feature = "profiler")]
-	{
-		_profiler_guard = profiler::start_profiling();
-	}
-	#[cfg(not(feature = "profiler"))]
-	{
-		_profiler_guard = Some(());
-	}
+    // Initialize the profiler guard if the feature is enabled
+    let mut _profiler_guard = None;
+    #[cfg(feature = "profiler")]
+    {
+        _profiler_guard = profiler::start_profiling();
+    }
+    #[cfg(not(feature = "profiler"))]
+    {
+        _profiler_guard = Some(());
+    }
 
-	// Run git-cliff
-	let exit_code = match git_cliff::run(args) {
-		Ok(()) => 0,
-		Err(e) => {
-			log::error!("{}", e);
-			1
-		}
-	};
+    // Run git-cliff
+    let exit_code = match git_cliff::run(args) {
+        Ok(()) => 0,
+        Err(e) => {
+            log::error!("{}", e);
+            1
+        }
+    };
 
-	// Report the profiler if the feature is enabled
-	#[cfg(feature = "profiler")]
-	{
-		profiler::finish_profiling(_profiler_guard)?;
-	}
+    // Report the profiler if the feature is enabled
+    #[cfg(feature = "profiler")]
+    {
+        profiler::finish_profiling(_profiler_guard)?;
+    }
 
-	process::exit(exit_code);
+    process::exit(exit_code);
 }
diff --git a/git-cliff/src/profiler.rs b/git-cliff/src/profiler.rs
index 708c6b70e6..100af81472 100644
--- a/git-cliff/src/profiler.rs
+++ b/git-cliff/src/profiler.rs
@@ -2,51 +2,49 @@ use git_cliff_core::error::Result;
 
 /// Creates a profiler guard and returns it.
 pub(crate) fn start_profiling() -> Option<pprof::ProfilerGuard<'static>> {
-	match pprof::ProfilerGuardBuilder::default()
-		.frequency(1000)
-		.blocklist(&["libc", "libgcc", "pthread", "vdso"])
-		.build()
-	{
-		Ok(guard) => Some(guard),
-		Err(e) => {
-			log::error!("failed to build profiler guard: {e}");
-			None
-		}
-	}
+    match pprof::ProfilerGuardBuilder::default()
+        .frequency(1000)
+        .blocklist(&["libc", "libgcc", "pthread", "vdso"])
+        .build()
+    {
+        Ok(guard) => Some(guard),
+        Err(e) => {
+            log::error!("failed to build profiler guard: {e}");
+            None
+        }
+    }
 }
 
 /// Reports the profiling results.
-pub(crate) fn finish_profiling(
-	profiler_guard: Option<pprof::ProfilerGuard>,
-) -> Result<()> {
-	match profiler_guard
-		.expect("failed to retrieve profiler guard")
-		.report()
-		.build()
-	{
-		Ok(report) => {
-			#[cfg(feature = "profiler-flamegraph")]
-			{
-				use std::fs::File;
-				let random = rand::random::<u64>();
-				let file = File::create(format!(
-					"{}.{random}.flamegraph.svg",
-					env!("CARGO_PKG_NAME"),
-				))?;
-				if let Err(e) = report.flamegraph(file) {
-					log::error!("failed to create flamegraph file: {e}");
-				}
-			}
+pub(crate) fn finish_profiling(profiler_guard: Option<pprof::ProfilerGuard>) -> Result<()> {
+    match profiler_guard
+        .expect("failed to retrieve profiler guard")
+        .report()
+        .build()
+    {
+        Ok(report) => {
+            #[cfg(feature = "profiler-flamegraph")]
+            {
+                use std::fs::File;
+                let random = rand::random::<u64>();
+                let file = File::create(format!(
+                    "{}.{random}.flamegraph.svg",
+                    env!("CARGO_PKG_NAME"),
+                ))?;
+                if let Err(e) = report.flamegraph(file) {
+                    log::error!("failed to create flamegraph file: {e}");
+                }
+            }
 
-			#[cfg(not(feature = "profiler-flamegraph"))]
-			{
-				log::info!("profiling report: {:?}", &report);
-			}
-		}
-		Err(e) => {
-			log::error!("failed to build profiler report: {e}");
-		}
-	}
+            #[cfg(not(feature = "profiler-flamegraph"))]
+            {
+                log::info!("profiling report: {:?}", &report);
+            }
+        }
+        Err(e) => {
+            log::error!("failed to build profiler report: {e}");
+        }
+    }
 
-	Ok(())
+    Ok(())
 }
diff --git a/rust-toolchain.toml b/rust-toolchain.toml
deleted file mode 100644
index 5d56faf9ae..0000000000
--- a/rust-toolchain.toml
+++ /dev/null
@@ -1,2 +0,0 @@
-[toolchain]
-channel = "nightly"
diff --git a/rustfmt.toml b/rustfmt.toml
deleted file mode 100644
index 3cca9ea3d1..0000000000
--- a/rustfmt.toml
+++ /dev/null
@@ -1,15 +0,0 @@
-edition = "2018"
-max_width = 85
-newline_style = "Unix"
-hard_tabs = true
-tab_spaces = 4
-use_field_init_shorthand = true
-reorder_imports = true
-binop_separator = "Back"
-format_code_in_doc_comments = true
-format_strings = true
-imports_layout = "Vertical"
-normalize_doc_attributes = true
-overflow_delimited_expr = true
-struct_field_align_threshold = 20
-wrap_comments = true
diff --git a/website/docs/installation/build-from-source.md b/website/docs/installation/build-from-source.md
index 7e33cfbc18..77c605c947 100644
--- a/website/docs/installation/build-from-source.md
+++ b/website/docs/installation/build-from-source.md
@@ -6,7 +6,7 @@ sidebar_position: 2
 
 ### Prerequisites
 
-- [Rust](https://www.rust-lang.org/) (nightly)
+- [Rust](https://www.rust-lang.org/)
   - The minimum supported Rust version is `1.75.0`.
 - [zlib](https://zlib.net/)
 - [libgit2](https://libgit2.org/)