use std::io::{self, IsTerminal};
use std::path::Path;
use std::time::{SystemTime, UNIX_EPOCH};
use clap::{Args, ValueEnum};
use oakum::changeset::{
default_stem, parse_packages_list, resolve_package_name, skipped_instruction_name, slugify,
write, KnopePresence, PackageSpec, PackagesError, UnknownReason, WriteError,
};
use oakum::plan::{BumpLevel, Workspace};
use super::changelog::heading_list;
use super::config::{load_config, require_config, LoadedConfig, UNMANAGED_FIX};
use super::fs::{repo_path_display, resolve_capability_path, write_file_exclusive};
use super::init::ensure_changeset_dir;
use super::install_pin::{self, PinPolicy};
use super::repository::{self, Repository};
use super::workspace::discover_validated;
use super::CliError;
use super::{ask, deliver_out, say_err};
#[derive(Debug, Args)]
pub(super) struct AddArgs {
#[arg(long, value_name = "LIST", allow_hyphen_values = true)]
packages: Option<String>,
#[arg(long, default_value = "")]
message: String,
#[arg(
long,
value_enum,
value_name = "SECTION",
requires = "message",
conflicts_with = "interactive"
)]
section: Option<Section>,
#[arg(long, value_name = "SLUG")]
name: Option<String>,
#[arg(long, conflicts_with_all = ["packages", "empty", "none"])]
interactive: bool,
#[arg(long, conflicts_with_all = ["packages", "none", "interactive"])]
empty: bool,
#[arg(long, conflicts_with_all = ["empty", "interactive"])]
none: bool,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, ValueEnum)]
enum Section {
Added,
Changed,
Deprecated,
Removed,
Fixed,
Security,
}
impl Section {
const fn heading(self) -> &'static str {
match self {
Self::Added => "Added",
Self::Changed => "Changed",
Self::Deprecated => "Deprecated",
Self::Removed => "Removed",
Self::Fixed => "Fixed",
Self::Security => "Security",
}
}
}
fn sectioned(message: &str, section: Option<Section>) -> String {
match section {
Some(section) if !message.is_empty() => {
format!(
"### {}\n\n{}",
section.heading(),
message.trim_start_matches('\n')
)
}
_ => message.to_owned(),
}
}
pub(super) fn run(args: AddArgs) -> Result<(), Box<dyn std::error::Error>> {
if args.interactive {
if !io::stdin().is_terminal() {
return Err(Box::new(CliError::new(
"`--interactive` needs a terminal; use `--packages <list>` (and optionally `--message` / `--name`) instead",
)));
}
return run_interactive(args.message, args.name);
}
let args = AddArgs {
message: String::from(args.message.trim()),
..args
};
if args.section.is_some() && args.message.is_empty() {
return Err(Box::new(CliError::new(
"`--section` needs a non-empty `--message` to put under the heading",
)));
}
if args.empty {
if args.packages.is_some() {
return Err(Box::new(CliError::new(
"`--empty` cannot be combined with `--packages`",
)));
}
return write_bump_file(
&[],
§ioned(&args.message, args.section),
args.name.as_deref(),
);
}
let Some(packages_text) = args.packages.as_deref() else {
return Err(Box::new(CliError::new(if args.none {
"`--none` needs `--packages` with `name:none` pairs"
} else {
"`oakum add` needs `--packages <list>`, `--empty`, `--none`, or `--interactive`"
})));
};
let specs = parse_packages_list(packages_text).map_err(|err| packages_cli_error(&err))?;
if args.none {
for spec in &specs {
if spec.level() != BumpLevel::None {
return Err(Box::new(CliError::new(format!(
"`--none` requires every `--packages` entry to use level `none` (got `{}:{}`)",
spec.name(),
spec.level()
))));
}
}
}
write_bump_file(
&specs,
§ioned(&args.message, args.section),
args.name.as_deref(),
)
}
fn gated_workspace() -> Result<(Repository, Workspace, LoadedConfig), Box<dyn std::error::Error>> {
let repo = repository::discover()?;
let config = load_config(&repo)?;
require_config(&config)?;
install_pin::gate(&repo, PinPolicy::Writer)?;
let workspace = discover_validated(&repo, &config)?;
Ok((repo, workspace, config))
}
fn run_interactive(
message_flag: String,
name_flag: Option<String>,
) -> Result<(), Box<dyn std::error::Error>> {
let (repo, workspace, config) = gated_workspace()?;
let package_names = package_names_sorted(&workspace);
say_err("Packages in this workspace:");
for name in &package_names {
say_err(&format!(" {name}"));
}
ask("Packages as name:level (comma-separated): ")?;
let packages_line = read_line()?;
let specs = parse_packages_list(&packages_line).map_err(|err| packages_cli_error(&err))?;
validate_specs(&specs, &workspace, &config)?;
let message = if message_flag.is_empty() {
ask("Summary (changelog note): ")?;
read_line()?
} else {
message_flag
};
let name = if let Some(stem) = name_flag {
Some(stem)
} else {
ask("Filename stem (empty to generate): ")?;
let line = read_line()?;
if line.is_empty() {
None
} else {
Some(line)
}
};
write_bump_file_in(
&repo,
&workspace,
&config,
&specs,
&message,
name.as_deref(),
)
}
fn write_bump_file(
specs: &[PackageSpec],
message: &str,
name: Option<&str>,
) -> Result<(), Box<dyn std::error::Error>> {
let (repo, workspace, config) = gated_workspace()?;
write_bump_file_in(&repo, &workspace, &config, specs, message, name)
}
pub(super) fn write_bump_file_in(
repo: &Repository,
workspace: &Workspace,
config: &LoadedConfig,
specs: &[PackageSpec],
message: &str,
name: Option<&str>,
) -> Result<(), Box<dyn std::error::Error>> {
if !specs.is_empty() {
validate_specs(specs, workspace, config)?;
}
let knope = knope_presence(repo)?;
let entries: Vec<(String, BumpLevel)> = specs
.iter()
.map(|spec| (String::from(spec.name()), spec.level()))
.collect();
if let Some(level) = entries.iter().map(|(_, level)| *level).max() {
let dropped = super::changelog::dropped_headings(message, level);
if !dropped.is_empty() {
return Err(Box::new(CliError::new(format!(
"the note has a heading with nothing under it ({}), so that section would reach no changelog: put text under the heading or remove it, or use `--none` for a change that is deliberately releaseless",
heading_list(&dropped)
))));
}
}
let body = bump_file_body(&entries, message, knope).map_err(|err| write_cli_error(&err))?;
let stem = match name {
Some(raw) => slugify(raw),
None => default_stem(unique_seed()),
};
let file_name = format!("{stem}.md");
if skipped_instruction_name(&file_name) {
return Err(Box::new(CliError::new(format!(
"refusing to write `{file_name}`: that name is reserved for instruction files in `.changeset/`"
))));
}
ensure_changeset_dir(repo.dir())?;
let relative =
resolve_capability_path(repo.dir(), repo.path(), Path::new(".changeset"))?.join(&file_name);
write_file_exclusive(repo.dir(), &relative, &body)
.map_err(|err| exclusive_create_error(&err, &relative))?;
let path = repo_path_display(&relative);
deliver_out(&path)
.map_err(|err| CliError::undelivered(format!("wrote `{path}`, but its path"), &err))?;
let releases = entries.iter().any(|(_, level)| *level != BumpLevel::None);
if releases && message.trim().is_empty() {
say_err(&format!(
"`{path}` has no note, so its changelog entry will be empty; write one below its frontmatter"
));
}
Ok(())
}
pub(super) fn bump_file_body(
entries: &[(String, BumpLevel)],
message: &str,
knope: KnopePresence,
) -> Result<String, WriteError> {
write(entries, &enveloped(message), knope)
}
pub(super) fn enveloped(message: &str) -> String {
if message.is_empty() {
return String::new();
}
let lead = if message.starts_with('\n') { "" } else { "\n" };
let tail = if message.ends_with('\n') { "" } else { "\n" };
format!("{lead}{message}{tail}")
}
fn validate_specs(
specs: &[PackageSpec],
workspace: &Workspace,
config: &LoadedConfig,
) -> Result<(), Box<dyn std::error::Error>> {
for spec in specs {
match resolve_package_name(spec.name(), workspace) {
Ok(id) => {
if config.refuses_intent(workspace, &id, spec.level()) {
return Err(Box::new(CliError::new(format!(
"`{}` is not version-managed, so every later step would refuse a bump file releasing it; {UNMANAGED_FIX}",
spec.name()
))));
}
}
Err(UnknownReason::Missing) => {
return Err(Box::new(CliError::new(format!(
"package `{}` is not in the workspace",
spec.name()
))));
}
Err(UnknownReason::Ambiguous) => {
return Err(Box::new(CliError::new(format!(
"package `{}` matches more than one workspace package",
spec.name()
))));
}
}
}
Ok(())
}
pub(super) fn knope_presence(
repo: &Repository,
) -> Result<KnopePresence, Box<dyn std::error::Error>> {
match repo.dir().metadata("knope.toml") {
Ok(meta) if meta.is_file() => Ok(KnopePresence::Present),
Ok(_) => Ok(KnopePresence::Absent),
Err(err) if err.kind() == io::ErrorKind::NotFound => Ok(KnopePresence::Absent),
Err(err) => Err(Box::new(CliError::new(format!(
"failed to inspect `knope.toml`: {err}"
)))),
}
}
fn exclusive_create_error(err: &io::Error, relative: &Path) -> Box<dyn std::error::Error> {
if err.kind() == io::ErrorKind::AlreadyExists {
Box::new(CliError::new(format!(
"refusing to overwrite existing bump file `{}`",
repo_path_display(relative)
)))
} else {
Box::new(CliError::new(err.to_string()))
}
}
fn package_names_sorted(workspace: &Workspace) -> Vec<String> {
let mut names: Vec<String> = workspace
.packages()
.map(|pkg| pkg.id().name.clone())
.collect();
names.sort();
names.dedup();
names
}
fn unique_seed() -> u64 {
match SystemTime::now().duration_since(UNIX_EPOCH) {
Ok(d) => d
.as_secs()
.wrapping_mul(1_000_000_000)
.wrapping_add(u64::from(d.subsec_nanos())),
Err(_) => 0,
}
}
fn read_line() -> Result<String, Box<dyn std::error::Error>> {
let mut line = String::new();
io::stdin().read_line(&mut line)?;
Ok(line.trim_end_matches(['\r', '\n']).to_string())
}
fn packages_cli_error(err: &PackagesError) -> Box<dyn std::error::Error> {
Box::new(CliError::new(err.to_string()))
}
fn write_cli_error(err: &WriteError) -> Box<dyn std::error::Error> {
Box::new(CliError::new(err.to_string()))
}
#[cfg(test)]
mod tests {
use super::enveloped;
#[test]
fn exclusive_create_maps_already_exists_to_overwrite() {
use std::io;
use std::path::Path;
let already = io::Error::new(
io::ErrorKind::AlreadyExists,
"failed to create `exists.md`: File exists",
);
let err = super::exclusive_create_error(&already, Path::new(".changeset/exists.md"));
assert!(err.to_string().contains("overwrite"), "{err}");
}
#[test]
fn exclusive_create_does_not_treat_permission_denied_as_overwrite() {
use std::io;
use std::path::Path;
let denied = io::Error::new(
io::ErrorKind::PermissionDenied,
"failed to create `exists.md`: Permission denied (os error 13)",
);
let err = super::exclusive_create_error(&denied, Path::new(".changeset/exists.md"));
let message = err.to_string();
assert!(!message.contains("overwrite"), "{message}");
assert!(message.contains("Permission denied"), "{message}");
}
#[test]
fn sectioned_prepends_the_heading_line_only_with_a_message() {
assert_eq!(
super::sectioned("note", Some(super::Section::Changed)),
"### Changed\n\nnote"
);
assert_eq!(
super::sectioned("\nnote\n", Some(super::Section::Security)),
"### Security\n\nnote\n"
);
assert_eq!(super::sectioned("note", None), "note");
assert_eq!(super::sectioned("", Some(super::Section::Fixed)), "");
}
#[test]
fn enveloped_adds_blank_line_and_trailing_newline() {
assert_eq!(enveloped(""), "");
assert_eq!(enveloped("note"), "\nnote\n");
assert_eq!(enveloped("note\n"), "\nnote\n");
assert_eq!(enveloped("\nnote\n"), "\nnote\n");
assert_eq!(enveloped("two\nlines"), "\ntwo\nlines\n");
}
}