use std::collections::{BTreeMap, HashSet};
use serde::Deserialize;
use crate::plan::{Package, ResolvesDependenciesAt, Versioning};
use crate::template::TemplateSource;
mod error_key;
mod parse_error;
mod schema;
mod wire;
pub use parse_error::ParseError;
use parse_error::{structured_toml_error, ParseErrorKind};
pub use schema::{names_another_schema, names_committed_schema, reference, schema, schema_json};
use wire::ConfigFile;
pub const VERSIONING_DESCRIPTION: &str = "\
How a breaking change file moves a version. `zero-major` (default) maps a major \
file to a minor bump while the package is below 1.0.0, matching SemVer 2.0 §4. \
`semver` is how a project releases 1.0.0: the next major file produces 1.0.0, \
and the key is then inert for that package. Override per package under `[packages.<name>]` \
so one crate can graduate without taking the rest of the workspace with it.";
pub const DEFAULT_SINGLE_TAG_FORMAT: &str = "v{{ version }}";
pub const DEFAULT_MULTI_TAG_FORMAT: &str = "{{ package }}/v{{ version }}";
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct OakumConfig {
deprecated_tool_version: bool,
change_files: bool,
conventional_commits: bool,
versioning: Versioning,
dependency_updates: DependencyUpdates,
pr_status: PrStatus,
tag_format: Option<TemplateSource>,
commit_message: Option<TemplateSource>,
title: Option<TemplateSource>,
template: Option<TemplateSource>,
private_packages: PrivatePackages,
include: Vec<String>,
exclude: Vec<String>,
packages: BTreeMap<String, PackageConfig>,
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub struct PrivatePackages {
version: bool,
tag: bool,
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Deserialize)]
#[serde(rename_all = "kebab-case")]
pub enum PrStatus {
Comment,
Summary,
#[default]
Both,
None,
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Deserialize)]
#[serde(rename_all = "kebab-case")]
pub enum DependencyUpdates {
#[default]
Ignore,
Release,
}
#[derive(Clone, Debug, Default, PartialEq, Eq)]
pub struct PackageConfig {
versioning: Option<Versioning>,
resolves_dependencies_at: Option<ResolvesDependenciesAt>,
extra_files: Vec<ExtraFile>,
publish_command: Option<String>,
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct ExtraFile {
path: String,
format: ExtraFileFormat,
key: String,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum ExtraFileFormat {
Json,
}
impl OakumConfig {
#[must_use]
pub fn defaults() -> Self {
Self {
deprecated_tool_version: false,
change_files: true,
conventional_commits: true,
versioning: Versioning::ZeroMajor,
dependency_updates: DependencyUpdates::Ignore,
pr_status: PrStatus::Both,
tag_format: None,
commit_message: None,
title: None,
template: None,
private_packages: PrivatePackages::default(),
include: Vec::new(),
exclude: Vec::new(),
packages: BTreeMap::new(),
}
}
#[must_use]
pub fn deprecated_tool_version(&self) -> bool {
self.deprecated_tool_version
}
#[must_use]
pub fn change_files(&self) -> bool {
self.change_files
}
#[must_use]
pub fn conventional_commits(&self) -> bool {
self.conventional_commits
}
#[must_use]
pub fn versioning(&self) -> Versioning {
self.versioning
}
#[must_use]
pub fn dependency_updates(&self) -> DependencyUpdates {
self.dependency_updates
}
#[must_use]
pub fn pr_status(&self) -> PrStatus {
self.pr_status
}
#[must_use]
pub fn tag_format(&self) -> Option<&TemplateSource> {
self.tag_format.as_ref()
}
#[must_use]
pub fn commit_message(&self) -> Option<&TemplateSource> {
self.commit_message.as_ref()
}
#[must_use]
pub fn title(&self) -> Option<&TemplateSource> {
self.title.as_ref()
}
#[must_use]
pub fn template(&self) -> Option<&TemplateSource> {
self.template.as_ref()
}
pub fn template_sources(&self) -> impl Iterator<Item = (&'static str, &TemplateSource)> {
[
("tag-format", self.tag_format.as_ref()),
("commit-message", self.commit_message.as_ref()),
("title", self.title.as_ref()),
("template", self.template.as_ref()),
]
.into_iter()
.filter_map(|(key, source)| source.map(|source| (key, source)))
}
#[must_use]
pub fn packages(&self) -> &BTreeMap<String, PackageConfig> {
&self.packages
}
#[must_use]
pub fn versioning_for(&self, package: &str) -> Versioning {
self.packages
.get(package)
.and_then(|pkg| pkg.versioning)
.unwrap_or(self.versioning)
}
#[must_use]
pub fn resolves_dependencies_at(&self, package: &str) -> Option<ResolvesDependenciesAt> {
self.packages
.get(package)
.and_then(|pkg| pkg.resolves_dependencies_at)
}
#[must_use]
pub fn extra_files_for(&self, package: &str) -> &[ExtraFile] {
self.packages
.get(package)
.map_or(&[], PackageConfig::extra_files)
}
#[must_use]
pub fn private_packages(&self) -> PrivatePackages {
self.private_packages
}
#[must_use]
pub fn include(&self) -> &[String] {
&self.include
}
#[must_use]
pub fn exclude(&self) -> &[String] {
&self.exclude
}
#[must_use]
pub fn selected(&self, package_name: &str) -> bool {
let included = self.include.is_empty() || self.include.iter().any(|n| n == package_name);
included && !self.exclude.iter().any(|n| n == package_name)
}
#[must_use]
pub fn version_managed(&self, package: &Package) -> bool {
self.version_managed_name(&package.id().name, package.publishable())
}
#[must_use]
pub fn tag_managed(&self, package: &Package) -> bool {
self.tag_managed_name(&package.id().name, package.publishable())
}
#[must_use]
pub fn version_managed_name(&self, package_name: &str, publishable: bool) -> bool {
self.selected(package_name) && (publishable || self.private_packages.version)
}
#[must_use]
pub fn tag_managed_name(&self, package_name: &str, publishable: bool) -> bool {
self.selected(package_name) && (publishable || self.private_packages.tag)
}
#[must_use]
pub fn publish_command_for(&self, package: &str) -> Option<&str> {
self.packages
.get(package)
.and_then(PackageConfig::publish_command)
}
pub fn validate_selection_names<'a>(
&self,
known: impl IntoIterator<Item = &'a str>,
) -> Result<(), ParseError> {
let known: HashSet<&str> = known.into_iter().collect();
for name in self.include.iter().chain(self.exclude.iter()) {
if !known.contains(name.as_str()) {
return Err(ParseError::new(ParseErrorKind::UnknownSelectionName(
name.clone(),
)));
}
}
Ok(())
}
}
impl PrivatePackages {
#[must_use]
pub fn version(&self) -> bool {
self.version
}
#[must_use]
pub fn tag(&self) -> bool {
self.tag
}
}
impl PackageConfig {
#[must_use]
pub fn versioning(&self) -> Option<Versioning> {
self.versioning
}
#[must_use]
pub fn resolves_dependencies_at(&self) -> Option<ResolvesDependenciesAt> {
self.resolves_dependencies_at
}
#[must_use]
pub fn extra_files(&self) -> &[ExtraFile] {
&self.extra_files
}
#[must_use]
pub fn publish_command(&self) -> Option<&str> {
self.publish_command.as_deref()
}
}
impl ExtraFile {
#[must_use]
pub fn path(&self) -> &str {
&self.path
}
#[must_use]
pub fn format(&self) -> ExtraFileFormat {
self.format
}
#[must_use]
pub fn key(&self) -> &str {
&self.key
}
}
pub fn parse(text: &str) -> Result<OakumConfig, ParseError> {
let file: ConfigFile =
toml::from_str(text).map_err(|error| structured_toml_error(text, &error))?;
if !file.change_files && !file.conventional_commits {
return Err(ParseError::new(
ParseErrorKind::BothIntentMechanismsDisabled,
));
}
let include = nonempty_package_names(file.include).map_err(ParseError::new)?;
let exclude = nonempty_package_names(file.exclude).map_err(ParseError::new)?;
Ok(OakumConfig {
deprecated_tool_version: file.tool_version.is_some(),
change_files: file.change_files,
conventional_commits: file.conventional_commits,
versioning: Versioning::from(file.versioning),
dependency_updates: file.dependency_updates,
pr_status: file.pr_status,
tag_format: nonempty_template(file.tag_format),
commit_message: nonempty_template(file.commit_message),
title: nonempty_template(file.title),
template: file.template,
private_packages: PrivatePackages::from(file.private_packages),
include,
exclude,
packages: file
.packages
.into_iter()
.map(|(name, pkg)| {
let pkg = pkg.into_package()?;
Ok((name, pkg))
})
.collect::<Result<BTreeMap<_, _>, ParseErrorKind>>()
.map_err(ParseError::new)?,
})
}
fn nonempty_package_names(names: Vec<String>) -> Result<Vec<String>, ParseErrorKind> {
let mut out = Vec::with_capacity(names.len());
for name in names {
let trimmed = name.trim();
if trimmed.is_empty() {
return Err(ParseErrorKind::EmptySelectionName);
}
if trimmed != name {
return Err(ParseErrorKind::EmptySelectionName);
}
out.push(name);
}
Ok(out)
}
fn nonempty_template(value: Option<TemplateSource>) -> Option<TemplateSource> {
match value {
Some(TemplateSource::Inline(body)) if body.is_empty() => None,
other => other,
}
}
fn tool_version_value(text: &str) -> Result<Option<toml::Spanned<toml::Value>>, ParseError> {
let file: ConfigFile =
toml::from_str(text).map_err(|error| structured_toml_error(text, &error))?;
Ok(file.tool_version)
}
pub fn remove_tool_version(text: &str) -> Result<Option<String>, ParseError> {
let Some(value) = tool_version_value(text)? else {
return Ok(None);
};
let document: toml_edit::Document<&str> = toml_edit::Document::parse(text)
.map_err(|_| ParseError::at(ParseErrorKind::InvalidSyntax, text, value.span().start))?;
let mut spans = Vec::new();
if let Some(item) = document.as_table().get("tool-version") {
item_spans(item, &mut spans);
}
let mut lines: Vec<_> = spans
.into_iter()
.map(|span| line_start(text, span.start)..line_end(text, span.end))
.collect();
lines.sort_by_key(|range| range.start);
let mut updated = String::with_capacity(text.len());
let mut cursor = 0;
for range in lines {
if range.start > cursor {
updated.push_str(&text[cursor..range.start]);
}
cursor = cursor.max(range.end);
}
updated.push_str(&text[cursor..]);
verify_removal(text, &updated)?;
Ok(Some(updated))
}
fn verify_removal(text: &str, updated: &str) -> Result<(), ParseError> {
let mut expected: toml::Table =
toml::from_str(text).map_err(|error| structured_toml_error(text, &error))?;
expected.remove("tool-version");
let actual: toml::Table =
toml::from_str(updated).map_err(|error| structured_toml_error(updated, &error))?;
if actual != expected {
return Err(ParseError::new(ParseErrorKind::RemovalChangedOtherKeys));
}
Ok(())
}
fn item_spans(item: &toml_edit::Item, spans: &mut Vec<std::ops::Range<usize>>) {
match item {
toml_edit::Item::None => {}
toml_edit::Item::Value(value) => spans.extend(value.span()),
toml_edit::Item::Table(table) => table_spans(table, spans),
toml_edit::Item::ArrayOfTables(array) => {
for table in array {
table_spans(table, spans);
}
}
}
}
fn table_spans(table: &toml_edit::Table, spans: &mut Vec<std::ops::Range<usize>>) {
let header = (!table.is_implicit() && !table.is_dotted())
.then(|| table.span())
.flatten();
let Some(header) = header else {
for (_, item) in table {
item_spans(item, spans);
}
return;
};
let mut end = header.end;
for (_, item) in table {
extend_body(item, &mut end, spans);
}
spans.push(header.start..end);
}
fn extend_body(item: &toml_edit::Item, end: &mut usize, spans: &mut Vec<std::ops::Range<usize>>) {
match item {
toml_edit::Item::Value(value) => {
if let Some(span) = value.span() {
*end = (*end).max(span.end);
}
}
toml_edit::Item::Table(dotted) if dotted.is_dotted() => {
for (_, child) in dotted {
extend_body(child, end, spans);
}
}
_ => item_spans(item, spans),
}
}
fn line_start(text: &str, offset: usize) -> usize {
let first = if text.starts_with('\u{feff}') {
'\u{feff}'.len_utf8()
} else {
0
};
text[..offset]
.rfind('\n')
.map_or(first, |newline| newline + 1)
}
fn line_end(text: &str, end: usize) -> usize {
text[end..]
.find('\n')
.map_or(text.len(), |newline| end + newline + 1)
}
#[cfg(test)]
mod tests {
use super::*;
use serde_json::{json, Value};
use crate::plan::BuildResolution;
#[test]
fn only_a_directive_naming_the_sibling_schema_counts() {
for named in [
"#:schema ./_schema.json\nchange-files = true\n",
"#:schema _schema.json\n",
"#:schema ../.changeset/_schema.json\n",
"#:schema ./sub/../_schema.json\n",
"\u{feff}# oakum\n\n#:schema ./_schema.json \r\nchange-files = true\r\n",
] {
assert!(names_committed_schema(named), "{named:?}");
}
for elsewhere in [
"",
"change-files = true\n",
"#:schema ../node_modules/@oakoss/oakum/schema.json\n",
"#:schema https://example.com/_schema.json\n",
"#:schema /abs/_schema.json\n",
"#:schema ./sub/_schema.json\n",
"#:schema ../_schema.json\n",
"#:schema ../../.changeset/_schema.json\n",
"#:schema\n",
"change-files = true\n#:schema ./_schema.json\n",
] {
assert!(!names_committed_schema(elsewhere), "{elsewhere:?}");
}
}
#[test]
fn only_a_directive_naming_another_schema_opts_out() {
for another in [
"#:schema ../node_modules/@oakoss/oakum/schema.json\n",
"#:schema https://example.com/_schema.json\n",
"#:schema ./sub/_schema.json\n",
] {
assert!(names_another_schema(another), "{another:?}");
}
for kept in [
"",
"change-files = true\n",
"#:schema\n",
"#:schema ./_schema.json\n",
"change-files = true\n#:schema ../node_modules/@oakoss/oakum/schema.json\n",
] {
assert!(!names_another_schema(kept), "{kept:?}");
}
}
#[test]
fn omitted_preference_keys_take_defaults() {
let cfg = parse("").expect("parse");
assert!(!cfg.deprecated_tool_version());
assert!(cfg.change_files());
assert!(cfg.conventional_commits());
assert_eq!(cfg.versioning(), Versioning::ZeroMajor);
assert_eq!(cfg.pr_status(), PrStatus::Both);
assert_eq!(cfg.private_packages(), PrivatePackages::default());
assert!(!cfg.private_packages().version());
assert!(!cfg.private_packages().tag());
assert!(cfg.include().is_empty(), "{:?}", cfg.include());
assert!(cfg.exclude().is_empty(), "{:?}", cfg.exclude());
assert!(cfg.packages().is_empty());
}
#[test]
fn unknown_key_is_an_error() {
let err = parse("tool-version = \"0.0.0\"\ngit-user = \"x\"\n").expect_err("unknown");
assert!(
err.to_string()
.contains("unknown configuration key `git-user`"),
"{err}"
);
assert!(!err.to_string().contains("expected one of"), "{err}");
}
#[test]
fn snake_case_key_is_unknown() {
let err = parse("tool-version = \"0.0.0\"\nchange_files = false\n").expect_err("snake");
assert!(
err.to_string()
.contains("unknown configuration key `change_files`"),
"{err}"
);
assert!(!err.to_string().contains("expected one of"), "{err}");
}
#[test]
fn a_key_scoped_into_a_table_is_named_with_its_table() {
let err = parse(concat!(
"tool-version = \"0.0.0\"\n",
"\n[private-packages]\nversion = true\n",
"\ncommit-message = \"chore: release\"\n"
))
.expect_err("scoped into the table above it");
assert!(
err.to_string()
.contains("unknown configuration key `private-packages.commit-message`"),
"{err}"
);
}
#[test]
fn a_dotted_key_inside_a_table_is_not_named_with_a_path_the_document_lacks() {
let err = parse(concat!(
"tool-version = \"0.0.0\"\n",
"\n[private-packages]\nnope.deeper = true\n"
))
.expect_err("unknown");
assert!(
err.to_string().contains("unknown configuration key"),
"{err}"
);
assert!(
!err.to_string().contains("private-packages.nope.deeper"),
"a path the document does not hold must not be printed: {err}"
);
}
#[test]
fn a_bracketed_line_in_a_string_does_not_invent_a_table() {
let err = parse(concat!(
"tool-version = \"0.0.0\"\n",
"commit-message = \"\"\"\n[private-packages]\n\"\"\"\n",
"version = true\n",
"\n[private-packages]\ntag = true\n"
))
.expect_err("unknown");
assert!(
err.to_string()
.contains("unknown configuration key `version`"),
"{err}"
);
assert!(!err.to_string().contains("private-packages"), "{err}");
}
#[test]
fn a_header_with_a_trailing_comment_is_still_the_keys_table() {
let err = parse(concat!(
"tool-version = \"0.0.0\"\n",
"\n[private-packages]\nversion = true\n",
"\n[packages.core] # a comment\nversion = \"x\"\n"
))
.expect_err("unknown");
assert!(
err.to_string()
.contains("unknown configuration key `packages.core.version`"),
"{err}"
);
}
#[test]
fn a_key_inside_a_nested_inline_table_is_named_in_full() {
let shallow = parse(concat!(
"tool-version = \"0.0.0\"\n",
"private-packages = { version = true, bogus = 1 }\n"
))
.expect_err("unknown");
assert!(
shallow
.to_string()
.contains("unknown configuration key `private-packages.bogus`"),
"{shallow}"
);
let nested = parse(concat!(
"tool-version = \"0.0.0\"\n",
"packages = { core = { publish = true } }\n"
))
.expect_err("unknown");
assert!(
nested
.to_string()
.contains("unknown configuration key `packages.core.publish`"),
"{nested}"
);
}
#[test]
fn a_key_under_an_array_of_tables_is_named_in_any_element() {
let one = parse(concat!(
"tool-version = \"0.0.0\"\n",
"\n[[packages.demo.extra-files]]\nnope = 1\n"
))
.expect_err("unknown");
assert!(
one.to_string()
.contains("unknown configuration key `packages.demo.extra-files.nope`"),
"{one}"
);
let first_of_two = parse(concat!(
"tool-version = \"0.0.0\"\n",
"\n[[packages.demo.extra-files]]\nnope = 1\n",
"\n[[packages.demo.extra-files]]\nfile = \"b\"\n"
))
.expect_err("unknown");
assert!(
first_of_two
.to_string()
.contains("unknown configuration key `packages.demo.extra-files.nope`"),
"{first_of_two}"
);
}
#[test]
fn an_inline_array_of_tables_names_its_key_too() {
let err = parse(concat!(
"tool-version = \"0.0.0\"\n",
"\n[packages.demo]\n",
"extra-files = [{ path = \"a.json\", format = \"json\", key = \"version\", nope = 1 }]\n"
))
.expect_err("unknown");
assert!(
err.to_string()
.contains("unknown configuration key `packages.demo.extra-files.nope`"),
"{err}"
);
let nested = parse(concat!(
"tool-version = \"0.0.0\"\n",
"packages = { core = { extra-files = [{ nope = 1 }] } }\n"
))
.expect_err("unknown");
assert!(
nested
.to_string()
.contains("unknown configuration key `packages.core.extra-files.nope`"),
"{nested}"
);
}
#[test]
fn a_quoted_segment_inside_an_inline_table_is_printed_quoted() {
let err = parse(concat!(
"tool-version = \"0.0.0\"\n",
"packages = { \"lodash.merge\" = { nope = 1 } }\n"
))
.expect_err("unknown");
assert!(
err.to_string()
.contains("unknown configuration key `packages.\"lodash.merge\".nope`"),
"{err}"
);
}
#[test]
fn a_segment_that_needs_quoting_is_printed_quoted() {
for (name, expected) in [
("lodash.merge", "packages.\"lodash.merge\".nope"),
("@scope/pkg", "packages.\"@scope/pkg\".nope"),
] {
let err = parse(&format!(
"tool-version = \"0.0.0\"\n\n[packages.\"{name}\"]\nnope = 1\n"
))
.expect_err("unknown");
assert!(
err.to_string()
.contains(&format!("unknown configuration key `{expected}`")),
"{name}: {err}"
);
}
}
#[test]
fn a_missing_required_key_is_not_reported_as_bad_syntax() {
let err = parse(concat!(
"tool-version = \"0.0.0\"\n",
"\n[[packages.demo.extra-files]]\npath = \"a.json\"\n"
))
.expect_err("missing field");
assert!(
err.to_string().contains("a required key is missing"),
"{err}"
);
assert!(!err.to_string().contains("invalid TOML syntax"), "{err}");
}
#[test]
fn a_quoted_or_spaced_header_is_named_as_resolved() {
for typed in ["[packages.\"core\"]", "[ packages . core ]"] {
let err = parse(&format!("tool-version = \"0.0.0\"\n\n{typed}\nbogus = 1\n"))
.expect_err("unknown");
assert!(
err.to_string()
.contains("unknown configuration key `packages.core.bogus`"),
"{typed}: {err}"
);
}
}
#[test]
fn versioning_and_package_overrides() {
let text = r#"
tool-version = "0.0.0"
versioning = "zero-major"
pr-status = "summary"
tag-format = "v{{version}}"
commit-message = "release {{version}}"
title = "Release"
template = "changelog.md"
[packages.core]
versioning = "semver"
resolves-dependencies-at = "build"
"#;
let cfg = parse(text).expect("parse");
assert_eq!(cfg.versioning(), Versioning::ZeroMajor);
assert_eq!(cfg.versioning_for("core"), Versioning::Semver);
assert_eq!(cfg.versioning_for("other"), Versioning::ZeroMajor);
assert_eq!(
cfg.resolves_dependencies_at("core"),
Some(ResolvesDependenciesAt::Build(BuildResolution::Declared))
);
assert_eq!(cfg.extra_files_for("core"), []);
assert_eq!(cfg.pr_status(), PrStatus::Summary);
assert_eq!(
cfg.tag_format(),
Some(&TemplateSource::Inline(String::from("v{{version}}")))
);
assert_eq!(
cfg.commit_message(),
Some(&TemplateSource::Inline(String::from("release {{version}}")))
);
assert_eq!(
cfg.title(),
Some(&TemplateSource::Inline(String::from("Release")))
);
assert_eq!(
cfg.template(),
Some(&TemplateSource::Inline(String::from("changelog.md")))
);
}
#[test]
fn template_file_table_parses() {
let cfg =
parse("tool-version = \"0.0.0\"\ntemplate = { file = \"notes.md\" }\n").expect("parse");
assert_eq!(
cfg.template(),
Some(&TemplateSource::File(String::from("notes.md")))
);
}
#[test]
fn template_empty_file_is_refused() {
let err =
parse("tool-version = \"0.0.0\"\ntemplate = { file = \"\" }\n").expect_err("empty");
assert!(
err.to_string().contains("invalid configuration value"),
"{err}"
);
}
#[test]
fn template_command_table_is_refused() {
let err = parse("tool-version = \"0.0.0\"\ntemplate = { command = \"pandoc\" }\n")
.expect_err("command");
assert!(err.to_string().contains("do not execute"), "{err}");
}
#[test]
fn preference_templates_share_the_template_source_shape() {
for key in ["tag-format", "commit-message", "title", "template"] {
let cfg = parse(&format!(
"tool-version = \"0.0.0\"\n{key} = {{ file = \"notes.md\" }}\n"
))
.unwrap_or_else(|err| panic!("{key} file: {err}"));
assert_eq!(
source_for(&cfg, key),
Some(&TemplateSource::File(String::from("notes.md"))),
"{key}"
);
let err = parse(&format!(
"tool-version = \"0.0.0\"\n{key} = {{ command = \"pandoc\" }}\n"
))
.expect_err(key);
assert!(err.to_string().contains("do not execute"), "{key}: {err}");
for blank in [r#"{ file = "" }"#, r#"{ file = " " }"#] {
let err =
parse(&format!("tool-version = \"0.0.0\"\n{key} = {blank}\n")).expect_err(key);
assert!(
err.to_string().contains("invalid configuration value"),
"{key} {blank}: {err}"
);
}
}
for key in ["tag-format", "commit-message", "title"] {
let empty = parse(&format!("tool-version = \"0.0.0\"\n{key} = \"\"\n"))
.unwrap_or_else(|err| panic!("{key} empty: {err}"));
assert_eq!(source_for(&empty, key), None, "{key}");
}
}
#[test]
fn inline_tag_format_body_renders() {
let cfg =
parse("tool-version = \"0.0.0\"\ntag-format = \"v{{ version }}\"\n").expect("parse");
let TemplateSource::Inline(body) = cfg.tag_format().expect("set") else {
panic!("expected an inline tag-format");
};
let out = crate::template::render("tag-format", body, json!({ "version": "1.2.3" }))
.expect("render");
assert_eq!(out, "v1.2.3");
}
fn source_for<'a>(cfg: &'a OakumConfig, key: &str) -> Option<&'a TemplateSource> {
match key {
"tag-format" => cfg.tag_format(),
"commit-message" => cfg.commit_message(),
"title" => cfg.title(),
"template" => cfg.template(),
other => panic!("unknown preference template key {other}"),
}
}
#[test]
fn unknown_package_key_is_an_error() {
let err = parse("tool-version = \"0.0.0\"\n\n[packages.core]\npublish = true\n")
.expect_err("unknown package key");
assert!(
err.to_string()
.contains("unknown configuration key `packages.core.publish`"),
"{err}"
);
assert!(!err.to_string().contains("expected one of"), "{err}");
}
#[test]
fn package_extra_files_parse() {
let text = r#"
tool-version = "0.0.0"
[[packages.review-cycle.extra-files]]
path = ".claude-plugin/plugin.json"
format = "json"
key = "version"
[[packages.review-cycle.extra-files]]
path = "/.claude-plugin/marketplace.json"
format = "json"
key = "plugins.{name=review-cycle}.version"
"#;
let cfg = parse(text).expect("parse");
let extras = cfg.extra_files_for("review-cycle");
assert_eq!(extras.len(), 2);
assert_eq!(extras[0].path(), ".claude-plugin/plugin.json");
assert_eq!(extras[0].format(), ExtraFileFormat::Json);
assert_eq!(extras[0].key(), "version");
assert_eq!(extras[1].path(), "/.claude-plugin/marketplace.json");
assert_eq!(extras[1].key(), "plugins.{name=review-cycle}.version");
assert_eq!(cfg.extra_files_for("other"), []);
}
#[test]
fn package_extra_files_reject_bad_key_and_format() {
let bad_key = parse(
r#"
tool-version = "0.0.0"
[[packages.demo.extra-files]]
path = "x.json"
format = "json"
key = "plugins.{name=}.version"
"#,
)
.expect_err("empty match value");
assert!(
bad_key.to_string().contains("invalid extra-files entry"),
"{bad_key}"
);
let leaf_match = parse(
r#"
tool-version = "0.0.0"
[[packages.demo.extra-files]]
path = "x.json"
format = "json"
key = "plugins.{name=review-cycle}"
"#,
)
.expect_err("match as leaf");
assert!(
leaf_match.to_string().contains("cannot end with"),
"{leaf_match}"
);
let bad_format = parse(
r#"
tool-version = "0.0.0"
[[packages.demo.extra-files]]
path = "x.json"
format = "toml"
key = "version"
"#,
)
.expect_err("toml format");
assert!(
bad_format
.to_string()
.contains("invalid configuration value"),
"{bad_format}"
);
}
#[test]
fn package_extra_files_path_and_trim_rules() {
let empty_path = parse(
r#"
tool-version = "0.0.0"
[[packages.demo.extra-files]]
path = ""
format = "json"
key = "version"
"#,
)
.expect_err("empty path");
assert!(
empty_path.to_string().contains("invalid extra-files entry"),
"{empty_path}"
);
let root_path = parse(
r#"
tool-version = "0.0.0"
[[packages.demo.extra-files]]
path = "/"
format = "json"
key = "version"
"#,
)
.expect_err("root path");
assert!(
root_path.to_string().contains("invalid extra-files entry"),
"{root_path}"
);
let empty_norm = parse(
r#"
tool-version = "0.0.0"
[[packages.demo.extra-files]]
path = "/.."
format = "json"
key = "version"
"#,
)
.expect_err("empty after normalize");
assert!(
empty_norm.to_string().contains("invalid extra-files entry"),
"{empty_norm}"
);
let root_escape = parse(
r#"
tool-version = "0.0.0"
[[packages.demo.extra-files]]
path = "/../x.json"
format = "json"
key = "version"
"#,
)
.expect_err("root escape");
assert!(
root_escape.to_string().contains("inside the repository"),
"{root_escape}"
);
let padded = parse(
r#"
tool-version = "0.0.0"
[[packages.demo.extra-files]]
path = " /.claude-plugin/marketplace.json"
format = "json"
key = " version "
"#,
)
.expect("trim");
let extras = padded.extra_files_for("demo");
assert_eq!(extras[0].path(), "/.claude-plugin/marketplace.json");
assert_eq!(extras[0].key(), "version");
let dotted_match = parse(
r#"
tool-version = "0.0.0"
[[packages.demo.extra-files]]
path = "x.json"
format = "json"
key = "plugins.{name=foo.bar}.version"
"#,
)
.expect("dotted match value");
assert_eq!(
dotted_match.extra_files_for("demo")[0].key(),
"plugins.{name=foo.bar}.version"
);
}
#[test]
fn duplicate_key_is_an_error() {
let text = "tool-version = \"0.0.0\"\ntool-version = \"redaction-canary\"\n";
let err = parse(text).expect_err("duplicate key");
assert!(
err.to_string().contains("duplicate configuration key")
&& err.to_string().contains("line 2, column 1")
&& !err.to_string().contains("redaction-canary"),
"{err}"
);
}
#[test]
fn invalid_versioning_value_is_an_error() {
let err = parse("tool-version = \"0.0.0\"\nversioning = \"calver\"\n")
.expect_err("bad versioning");
assert!(
err.to_string().contains("invalid configuration value"),
"{err}"
);
assert!(!err.to_string().contains("calver"), "{err}");
}
#[test]
fn a_config_without_tool_version_parses() {
let cfg = parse("change-files = true\n").expect("tool-version is not required");
assert!(!cfg.deprecated_tool_version());
}
#[test]
fn a_range_in_the_deprecated_key_parses() {
for req in ["^0.0.0", ">=0.0.0", "*", "1"] {
let cfg = parse(&format!("tool-version = \"{req}\"\n")).expect(req);
assert!(cfg.deprecated_tool_version(), "{req}");
}
}
#[test]
fn a_garbage_value_in_the_deprecated_key_parses() {
for value in ["\"garbage\"", "1", "[\"0.1.0\"]", "{ pinned = true }"] {
let cfg = parse(&format!("tool-version = {value}\n")).expect(value);
assert!(cfg.deprecated_tool_version(), "{value}");
}
}
#[test]
fn both_intent_mechanisms_off_is_an_error() {
let err =
parse("tool-version = \"0.0.0\"\nchange-files = false\nconventional-commits = false\n")
.expect_err("both off");
assert!(
err.to_string().contains("change-files")
&& err.to_string().contains("conventional-commits"),
"{err}"
);
}
#[test]
fn invalid_pr_status_is_an_error() {
let err =
parse("tool-version = \"0.0.0\"\npr-status = \"checks\"\n").expect_err("bad pr-status");
assert!(
err.to_string().contains("invalid configuration value")
&& !err.to_string().contains("checks"),
"{err}"
);
}
#[test]
fn defaults_are_both_intent_on_and_unpinned() {
let cfg = OakumConfig::defaults();
assert!(!cfg.deprecated_tool_version());
assert!(cfg.change_files() && cfg.conventional_commits());
assert_eq!(cfg.versioning(), Versioning::ZeroMajor);
assert_eq!(cfg.pr_status(), PrStatus::Both);
assert_eq!(cfg.private_packages(), PrivatePackages::default());
assert!(cfg.include().is_empty(), "{:?}", cfg.include());
assert!(cfg.exclude().is_empty(), "{:?}", cfg.exclude());
}
#[test]
fn private_packages_axes_are_independent() {
let version_only = parse(
r#"
tool-version = "0.0.0"
private-packages = { version = true, tag = false }
"#,
)
.expect("parse");
assert!(version_only.private_packages().version());
assert!(!version_only.private_packages().tag());
assert!(version_only.version_managed_name("priv", false));
assert!(!version_only.tag_managed_name("priv", false));
assert!(version_only.version_managed_name("pub", true));
assert!(version_only.tag_managed_name("pub", true));
let tag_only = parse(
r#"
tool-version = "0.0.0"
private-packages = { version = false, tag = true }
"#,
)
.expect("parse");
assert!(!tag_only.private_packages().version());
assert!(tag_only.private_packages().tag());
assert!(!tag_only.version_managed_name("priv", false));
assert!(tag_only.tag_managed_name("priv", false));
}
#[test]
fn include_exclude_selection_math() {
let all = parse("tool-version = \"0.0.0\"\n").expect("parse");
assert!(all.selected("a"));
assert!(all.selected("b"));
let included = parse(
r#"
tool-version = "0.0.0"
include = ["a", "b"]
"#,
)
.expect("parse");
assert!(included.selected("a"));
assert!(included.selected("b"));
assert!(!included.selected("c"));
let excluded = parse(
r#"
tool-version = "0.0.0"
exclude = ["b"]
"#,
)
.expect("parse");
assert!(excluded.selected("a"));
assert!(!excluded.selected("b"));
let both = parse(
r#"
tool-version = "0.0.0"
include = ["a", "b"]
exclude = ["b"]
"#,
)
.expect("parse");
assert!(both.selected("a"));
assert!(!both.selected("b"));
assert!(!both.selected("c"));
assert!(!both.version_managed_name("a", false));
assert!(both.version_managed_name("a", true));
assert!(!both.version_managed_name("b", true));
}
#[test]
fn empty_include_exclude_names_are_refused() {
for text in [
"tool-version = \"0.0.0\"\ninclude = [\"\"]\n",
"tool-version = \"0.0.0\"\nexclude = [\"\"]\n",
"tool-version = \"0.0.0\"\ninclude = [\" \"]\n",
"tool-version = \"0.0.0\"\nexclude = [\"\\t\"]\n",
"tool-version = \"0.0.0\"\ninclude = [\" foo \"]\n",
"tool-version = \"0.0.0\"\nexclude = [\"bar \"]\n",
] {
let err = parse(text).expect_err(text);
assert!(
err.to_string().contains("non-empty package names"),
"{text}: {err}"
);
}
}
#[test]
fn unknown_selection_names_are_not_validated_at_parse() {
let cfg = parse(
r#"
tool-version = "0.0.0"
include = ["ghost"]
exclude = ["also-ghost"]
"#,
)
.expect("parse without workspace");
assert_eq!(cfg.include(), &["ghost".to_owned()]);
assert_eq!(cfg.exclude(), &["also-ghost".to_owned()]);
let err = cfg.validate_selection_names(["real"]).expect_err("unknown");
assert!(
err.to_string().contains("unknown package name") && err.to_string().contains("ghost"),
"{err}"
);
cfg.validate_selection_names(["ghost", "also-ghost", "extra"])
.expect("known");
}
#[test]
fn publish_command_parses_and_rejects_empty() {
let cfg = parse(
r#"
tool-version = "0.0.0"
[packages.demo]
publish-command = " pnpm publish "
"#,
)
.expect("parse");
assert_eq!(cfg.publish_command_for("demo"), Some("pnpm publish"));
assert_eq!(
cfg.packages()
.get("demo")
.and_then(PackageConfig::publish_command),
Some("pnpm publish")
);
assert_eq!(cfg.publish_command_for("other"), None);
for blank in [r#""""#, r#"" ""#] {
let err = parse(&format!(
"tool-version = \"0.0.0\"\n\n[packages.demo]\npublish-command = {blank}\n"
))
.expect_err(blank);
assert!(
err.to_string().contains("publish-command")
&& err.to_string().contains("must not be empty"),
"{blank}: {err}"
);
}
}
fn removed(text: &str) -> String {
remove_tool_version(text)
.expect("valid config")
.expect("key present")
}
#[test]
fn remove_tool_version_keeps_a_schema_directive_on_line_one() {
assert_eq!(
removed("#:schema ./_schema.json\ntool-version = \"0.5.1\"\nchange-files = true\n"),
"#:schema ./_schema.json\nchange-files = true\n"
);
assert_eq!(
removed("#:schema ./_schema.json\ntool-version = \"0.5.1\"\n\n[packages.a]\npublish-command = \"true\"\n"),
"#:schema ./_schema.json\n\n[packages.a]\npublish-command = \"true\"\n"
);
}
#[test]
fn remove_tool_version_takes_its_trailing_comment_and_keeps_the_ones_above() {
assert_eq!(
removed(
"# header\n\n# pinned\ntool-version = \"0.0.9\" # note\n\nchange-files = true\n"
),
"# header\n\n# pinned\n\nchange-files = true\n"
);
}
#[test]
fn remove_tool_version_when_it_is_last_or_alone() {
assert_eq!(
removed("change-files = true\ntool-version = \"0.1.0\"\n"),
"change-files = true\n"
);
assert_eq!(
removed("change-files = true\ntool-version = \"0.1.0\""),
"change-files = true\n"
);
assert_eq!(removed("tool-version = \"0.1.0\"\n"), "");
assert_eq!(
removed("#:schema ./_schema.json\ntool-version = \"0.1.0\"\n"),
"#:schema ./_schema.json\n"
);
}
#[test]
fn remove_tool_version_keeps_crlf() {
assert_eq!(
removed(
"#:schema ./_schema.json\r\ntool-version = \"0.1.0\"\r\nchange-files = true\r\n"
),
"#:schema ./_schema.json\r\nchange-files = true\r\n"
);
}
#[test]
fn remove_tool_version_removes_every_value_shape() {
for value in [
"1",
"true",
"[1, 2]",
"[\n \"0.1.0\", # inside\n \"0.2.0\",\n]",
"{ pinned = true }",
"\"\"\"\n0.1.0\n\"\"\"",
] {
assert_eq!(
removed(&format!(
"# above\ntool-version = {value}\nchange-files = true\n"
)),
"# above\nchange-files = true\n",
"{value}"
);
}
}
#[test]
fn remove_tool_version_removes_a_table_and_its_subtables() {
assert_eq!(
removed(
"change-files = true\n\n# above\n[tool-version] # header note\na = 1\n# inside\nb.c = 2\n\n[tool-version.sub]\nd = 3\n\n# next\n[packages.x]\npublish-command = \"true\"\n"
),
"change-files = true\n\n# above\n\n\n# next\n[packages.x]\npublish-command = \"true\"\n"
);
assert_eq!(
removed("change-files = true\n\n[tool-version.sub]\nd = 3\n"),
"change-files = true\n\n"
);
assert_eq!(removed("[tool-version]\n"), "");
}
#[test]
fn remove_tool_version_keeps_tables_between_a_body_and_its_headed_descendant() {
assert_eq!(
removed(
"#:schema ./_schema.json\n[tool-version]\nsub.a = 1\n\n[packages.x]\npublish-command = \"true\"\n\n[tool-version.sub.deeper]\nb = 1\n"
),
"#:schema ./_schema.json\n\n[packages.x]\npublish-command = \"true\"\n\n"
);
assert_eq!(
removed(
"[tool-version]\nsub.a = 1\n\n[packages.x]\npublish-command = \"true\"\n\n[tool-version.sub.deeper]\nb = 1\n\n[packages.y]\npublish-command = \"true\"\n"
),
"\n[packages.x]\npublish-command = \"true\"\n\n\n[packages.y]\npublish-command = \"true\"\n"
);
}
#[test]
fn remove_tool_version_keeps_a_byte_order_mark() {
assert_eq!(
removed("\u{feff}tool-version = \"1\"\nchange-files = true\n"),
"\u{feff}change-files = true\n"
);
}
#[test]
fn remove_tool_version_removes_dotted_keys() {
assert_eq!(
removed("tool-version.a = 1\nchange-files = true\ntool-version.b.c = 2 # note\n"),
"change-files = true\n"
);
}
#[test]
fn remove_tool_version_removes_an_array_of_tables() {
assert_eq!(
removed(
"change-files = true\n\n[[tool-version]]\na = 1\n\n# second\n[[tool-version]]\nb = 1\n"
),
"change-files = true\n\n\n# second\n"
);
}
#[test]
fn remove_tool_version_leaves_a_config_without_the_key_alone() {
assert_eq!(
remove_tool_version("# tool-version = \"0.1.0\"\nchange-files = true\n")
.expect("valid config"),
None
);
}
#[test]
fn remove_tool_version_refuses_an_invalid_config() {
for text in ["not toml", "tool-version = \"0.1.0\"\nnope = 1\n"] {
remove_tool_version(text).expect_err(text);
}
}
#[test]
fn a_removal_that_drops_another_key_is_refused() {
let text = "tool-version = \"0.1.0\"\n\n[packages.x]\npublish-command = \"true\"\n";
verify_removal(text, "\n[packages.x]\npublish-command = \"true\"\n").expect("only the key");
let err = verify_removal(text, "").expect_err("packages.x dropped");
assert!(
matches!(err.kind, ParseErrorKind::RemovalChangedOtherKeys),
"{err:?}"
);
}
#[test]
fn schema_refuses_unknown_keys_and_accepts_any_tool_version() {
let schema = schema();
assert_eq!(schema["additionalProperties"], false);
assert_eq!(schema.get("required"), None);
let tool_version = schema["properties"]["tool-version"]
.as_object()
.expect("tool-version");
assert_eq!(
tool_version.keys().collect::<Vec<_>>(),
["description"],
"a deprecated key the binary accepts in any shape constrains nothing"
);
let pkg = &schema["properties"]["packages"]["additionalProperties"];
assert_eq!(pkg["additionalProperties"], false);
assert_eq!(pkg["properties"]["versioning"].get("default"), None);
assert_eq!(
pkg["properties"]["resolves-dependencies-at"]["enum"],
json!(["build"])
);
assert_eq!(pkg["properties"]["publish-command"]["minLength"], 1);
assert_eq!(
schema["properties"]["private-packages"]["default"],
json!({ "version": false, "tag": false })
);
assert_eq!(schema["properties"]["include"]["default"], json!([]));
assert_eq!(schema["properties"]["exclude"]["default"], json!([]));
assert_eq!(schema["then"], false);
for key in ["tag-format", "commit-message", "title", "template"] {
let file_form = &schema["properties"][key]["oneOf"][1];
assert_eq!(file_form["additionalProperties"], false, "{key}");
assert_eq!(file_form["required"], json!(["file"]), "{key}");
assert_eq!(file_form["properties"]["file"]["minLength"], 1, "{key}");
assert_eq!(
file_form["properties"]["file"]["pattern"], r".*\S.*",
"{key}"
);
}
}
fn parser_keys(text: &str) -> Vec<String> {
let err = toml::from_str::<ConfigFile>(text)
.expect_err("`nope` is not a key")
.to_string();
let line = err
.lines()
.find(|line| line.contains("unknown field `nope`"))
.unwrap_or_else(|| panic!("{err}"));
let (_, expected) = line.split_once(", expected ").expect(line);
let mut keys: Vec<String> = expected
.split('`')
.skip(1)
.step_by(2)
.map(String::from)
.collect();
keys.sort_unstable();
keys
}
fn schema_keys(object: &Value) -> Vec<String> {
let mut keys: Vec<String> = object["properties"]
.as_object()
.expect("properties")
.keys()
.cloned()
.collect();
keys.sort_unstable();
keys
}
#[test]
fn the_schema_names_every_key_the_parser_accepts() {
let schema = schema();
let package = &schema["properties"]["packages"]["additionalProperties"];
for (text, object) in [
("nope = 1\n", &schema),
(
"[private-packages]\nnope = 1\n",
&schema["properties"]["private-packages"],
),
("[packages.demo]\nnope = 1\n", package),
(
"[[packages.demo.extra-files]]\nnope = 1\n",
&package["properties"]["extra-files"]["items"],
),
] {
assert_eq!(parser_keys(text), schema_keys(object), "{text}");
}
}
#[test]
fn schema_enums_match_parse() {
let schema = schema();
assert_eq!(
schema["properties"]["versioning"]["enum"],
json!(["zero-major", "semver"])
);
assert_eq!(
schema["properties"]["pr-status"]["enum"],
json!(["comment", "summary", "both", "none"])
);
for value in ["zero-major", "semver"] {
parse(&format!(
"tool-version = \"0.0.0\"\nversioning = \"{value}\"\n"
))
.unwrap_or_else(|err| panic!("{value}: {err}"));
}
for value in ["comment", "summary", "both", "none"] {
parse(&format!(
"tool-version = \"0.0.0\"\npr-status = \"{value}\"\n"
))
.unwrap_or_else(|err| panic!("{value}: {err}"));
}
parse(
"tool-version = \"0.0.0\"\n\n[packages.core]\nresolves-dependencies-at = \"install\"\n",
)
.expect_err("install is derived");
assert_eq!(
schema["properties"]["packages"]["additionalProperties"]["properties"]["extra-files"]
["items"]["properties"]["format"]["enum"],
json!(["json"])
);
}
#[test]
fn schema_versioning_description_states_graduation() {
let schema = schema();
let description = schema["properties"]["versioning"]["description"]
.as_str()
.expect("description");
assert_eq!(description, VERSIONING_DESCRIPTION);
assert!(description.contains("1.0.0"), "{description}");
}
#[test]
fn schema_json_keeps_short_scalar_arrays_inline() {
let body = schema_json();
assert!(
body.contains("\"required\": [\"change-files\", \"conventional-commits\"]"),
"{body}"
);
assert!(body.ends_with("}\n"), "{body}");
}
#[test]
fn schema_json_round_trips_to_schema() {
let body = schema_json();
let parsed: Value = serde_json::from_str(&body).expect("schema_json is JSON");
assert_eq!(parsed, schema());
assert!(body.ends_with('\n'));
}
}