feat: add --capitalize-commit option to capitalize commit message in cargo-smart-release

eatradish committed 3 years ago

Commit 4a244a21 parent b8db2078 files · +36 −9Browse files

Unified · Split

8 files

cargo-smart-release/src/changelog/write.rs +10 −2
cargo-smart-release/src/cli/main.rs +4 −0
cargo-smart-release/src/cli/options.rs +8 −0
cargo-smart-release/src/command/changelog.rs +2 −0
cargo-smart-release/src/command/mod.rs +2 −0
cargo-smart-release/src/command/release/manifest.rs +2 −0
cargo-smart-release/src/command/release/mod.rs +4 −3
cargo-smart-release/tests/changelog/write_and_parse/mod.rs +4 −4

cargo-smart-release/src/changelog/write.rs+10−2

         mut out: impl std::fmt::Write,
         link_mode: &Linkables,
         components: Components,
+        capitalize_commit: bool,
     ) -> std::fmt::Result {
         match self {
             Section::Verbatim { text, .. } => {
                 let section_level = *heading_level + 1;
                 for segment in segments {
-                    segment.write_to(section_level, link_mode, components, &mut out)?;
+                    segment.write_to(section_level, link_mode, components, capitalize_commit, &mut out)?;
                 }
                 if !unknown.is_empty() && components.contains(Components::HTML_TAGS) {
                     writeln!(out, "{}", Section::UNKNOWN_TAG_START)?;
         mut out: impl std::fmt::Write,
         link_mode: &Linkables,
         components: Components,
+        capitalize_commit: bool,
     ) -> std::fmt::Result {
         for section in &self.sections {
-            section.write_to(&mut out, link_mode, components)?;
+            section.write_to(&mut out, link_mode, components, capitalize_commit)?;
         }
         Ok(())
     }
         section_level: usize,
         link_mode: &Linkables,
         components: Components,
+        capitalize_commit: bool,
         mut out: impl std::fmt::Write,
     ) -> std::fmt::Result {
         let write_html = components.contains(Components::HTML_TAGS);
                     for message in messages {
                         match message {
                             Message::Generated { title, id, body } => {
+                                let title = if capitalize_commit {
+                                    capitalize_message_title(title)
+                                } else {
+                                    Cow::Borrowed(title.as_str())
+                                };
                                 if write_html {
                                     writeln!(
                                         out,

cargo-smart-release/src/cli/main.rs+4−0

             no_links,
             without,
             allow_dirty,
+            capitalize_commit,
         } => {
             init_logging(false);
             command::changelog(
                     preview: !no_preview,
                     dependencies: !no_dependencies,
                     generator_segments: names_to_segment_selection(&without)?,
+                    capitalize_commit,
                 },
                 crates,
             )?
             allow_fully_generated_changelogs,
             no_dependencies,
             no_isolate_dependencies_from_breaking_changes,
+            capitalize_commit
         } => {
             let verbose = execute || verbose;
             init_logging(verbose);
                     allow_fully_generated_changelogs,
                     changelog_links: !no_changelog_links,
                     allow_changelog_github_release: !no_changelog_github_release,
+                    capitalize_commit,
                 },
                 crates,
                 to_bump_spec(bump.as_deref().unwrap_or(DEFAULT_BUMP_SPEC))?,

cargo-smart-release/src/cli/options.rs+8−0

         /// depend on an unpublished version with "--no-validate".
         #[clap(long, help_heading = Some("EXPERT"))]
         ignore_instability: bool,
+        /// Automatically capitalize commit message
+        #[clap(long, help_heading = Some("CHANGELOG"))]
+        capitalize_commit: bool,
     },
     #[clap(name = "changelog", version = clap::crate_version!())]
     /// Generate changelogs from commit histories, non-destructively.
         /// Do not generate links to commits and issues when writing the changelogs. This currently only works for GitHub.
         #[clap(long, help_heading = Some("CUSTOMIZATION"))]
         no_links: bool,
+        /// Automatically capitalize commit message
+        #[clap(long, help_heading = Some("CUSTOMIZATION"))]
+        capitalize_commit: bool,
     },
 }

cargo-smart-release/src/command/changelog.rs+2−0

         dry_run,
         preview,
         no_links,
+        capitalize_commit,
         ..
     } = opts;
     let bump_spec = if dependencies { BumpSpec::Auto } else { BumpSpec::Keep };
                 } else {
                     Components::all()
                 },
+                capitalize_commit,
             )
             .map_err(|err| std::io::Error::new(std::io::ErrorKind::Other, err))?;
             file.write_all(buf.as_bytes())

cargo-smart-release/src/command/mod.rs+2−0

         pub allow_fully_generated_changelogs: bool,
         pub changelog_links: bool,
         pub allow_changelog_github_release: bool,
+        pub capitalize_commit: bool,
     }
 }
 #[path = "release/mod.rs"]
         // All the segments to generate
         pub generator_segments: segment::Selection,
         pub no_links: bool,
+        pub capitalize_commit: bool,
     }
 }
 #[path = "changelog.rs"]

cargo-smart-release/src/command/release/manifest.rs+2−0

     Options {
         dry_run,
         generator_segments,
+        capitalize_commit,
         ..
     }: Options,
 ) -> anyhow::Result<GatherOutcome<'meta>> {
                 } else {
                     changelog::write::Components::all()
                 },
+                capitalize_commit
             )?;
             lock.with_mut(|file| file.write_all(write_buf.as_bytes()))?;
             *made_change |= previous_content.map(|previous| write_buf != previous).unwrap_or(true);

cargo-smart-release/src/command/release/mod.rs+4−3

             commit_id,
             release_section_by_publishee
                 .get(&publishee.name.as_str())
-                .and_then(|s| section_to_string(s, WriteMode::Tag)),
+                .and_then(|s| section_to_string(s, WriteMode::Tag, options.capitalize_commit)),
             &ctx.base,
             options,
         )? {
         for (publishee, new_version) in successful_publishees_and_version {
             release_section_by_publishee
                 .get(&publishee.name.as_str())
-                .and_then(|s| section_to_string(s, WriteMode::GitHubRelease))
+                .and_then(|s| section_to_string(s, WriteMode::GitHubRelease, options.capitalize_commit))
                 .map(|release_notes| github::create_release(publishee, new_version, &release_notes, options, &ctx.base))
                 .transpose()?;
         }
     GitHubRelease,
 }
-fn section_to_string(section: &Section, mode: WriteMode) -> Option<String> {
+fn section_to_string(section: &Section, mode: WriteMode, capitalize_commit: bool) -> Option<String> {
     let mut b = String::new();
     section
         .write_to(
                 WriteMode::Tag => changelog::write::Components::empty(),
                 WriteMode::GitHubRelease => changelog::write::Components::DETAIL_TAGS,
             },
+            capitalize_commit,
         )
         .ok()
         .map(|_| b)

cargo-smart-release/tests/changelog/write_and_parse/mod.rs+4−4

@@ -59,7 +59,7 @@ fn conventional_write_empty_messages() -> Result { · 58 unmodified lines
59	let log = log.clone();	59	let log = log.clone();
60	for _round in 1..=2 {	60	for _round in 1..=2 {
61	let mut md = String::new();	61	let mut md = String::new();
62	log.write_to(&mut md, link_mode, changelog::write::Components::all())?;	62	log.write_to(&mut md, link_mode, changelog::write::Components::all(), false)?;
63	insta::assert_snapshot!(md);	63	insta::assert_snapshot!(md);
64		64
65	let parsed_log = ChangeLog::from_markdown(&md);	65	let parsed_log = ChangeLog::from_markdown(&md);
@@ -72,7 +72,7 @@ fn conventional_write_empty_messages() -> Result { · 6 unmodified lines
72	] {	72	] {
73	for section in &log.sections {	73	for section in &log.sections {
74	let mut buf = String::new();	74	let mut buf = String::new();
75	section.write_to(&mut buf, &changelog::write::Linkables::AsText, *components)?;	75	section.write_to(&mut buf, &changelog::write::Linkables::AsText, *components, false)?;
76	insta::assert_snapshot!(buf);	76	insta::assert_snapshot!(buf);
77	}	77	}
78	}	78	}
@@ -164,7 +164,7 @@ fn all_section_types_round_trips_lossy() -> Result { · 85 unmodified lines
164	] {	164	] {
165	// NOTE: we can't run this a second time as the statistical information will be gone (it was never parsed back)	165	// NOTE: we can't run this a second time as the statistical information will be gone (it was never parsed back)
166	let mut md = String::new();	166	let mut md = String::new();
167	log.write_to(&mut md, link_mode, changelog::write::Components::all())?;	167	log.write_to(&mut md, link_mode, changelog::write::Components::all(), false)?;
168	insta::assert_snapshot!(md);	168	insta::assert_snapshot!(md);
169		169
170	let parsed_log = ChangeLog::from_markdown(&md);	170	let parsed_log = ChangeLog::from_markdown(&md);
@@ -178,7 +178,7 @@ fn all_section_types_round_trips_lossy() -> Result { · 7 unmodified lines
178	] {	178	] {
179	for section in &log.sections {	179	for section in &log.sections {
180	let mut buf = String::new();	180	let mut buf = String::new();
181	section.write_to(&mut buf, &changelog::write::Linkables::AsText, *components)?;	181	section.write_to(&mut buf, &changelog::write::Linkables::AsText, *components, false)?;
182	insta::assert_snapshot!(buf);	182	insta::assert_snapshot!(buf);
183	}	183	}
184	}	184	}