use alloc::collections::BTreeSet;
use alloc::string::String;
use alloc::vec::Vec;
use core::fmt;
use core::str::FromStr;
use crate::plan::BumpLevel;
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct ChangeFile {
entries: Vec<(String, BumpLevel)>,
note: String,
}
impl ChangeFile {
#[must_use]
pub fn entries(&self) -> &[(String, BumpLevel)] {
&self.entries
}
#[must_use]
pub fn note(&self) -> &str {
&self.note
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum ParseError {
Bom,
MissingOpeningDelimiter,
MissingClosingDelimiter,
BlankLineInFrontmatter,
DuplicatePackage(String),
InvalidLine(String),
UnquotedScopedName(String),
QuotedUnscopedName(String),
UnknownLevel(String),
}
impl fmt::Display for ParseError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::Bom => f.write_str("bump file must not start with a UTF-8 BOM"),
Self::MissingOpeningDelimiter => f.write_str("bump file must start with --- on line 1"),
Self::MissingClosingDelimiter => f.write_str("bump file is missing the closing ---"),
Self::BlankLineInFrontmatter => {
f.write_str("bump file frontmatter must not contain blank lines")
}
Self::DuplicatePackage(name) => {
write!(f, "bump file names package `{name}` more than once")
}
Self::InvalidLine(line) => {
write!(f, "bump file frontmatter line is not `name: level`: {line}")
}
Self::UnquotedScopedName(name) => write!(
f,
"scoped package `{name}` must be quoted (`\"{name}\": level`)"
),
Self::QuotedUnscopedName(name) => write!(
f,
"package `{name}` must not be quoted (only scoped npm names are quoted)"
),
Self::UnknownLevel(level) => {
write!(
f,
"bump level `{level}` is not none, patch, minor, or major"
)
}
}
}
}
impl core::error::Error for ParseError {}
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum WriteError {
EmptyPackageName,
DuplicatePackage(String),
InvalidPackageName(String),
ScopedPackageWithKnope(String),
}
impl fmt::Display for WriteError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::EmptyPackageName => f.write_str("bump file package name must not be empty"),
Self::DuplicatePackage(name) => {
write!(f, "bump file names package `{name}` more than once")
}
Self::InvalidPackageName(name) => {
write!(f, "bump file package name `{name}` is not writable in the intersection grammar")
}
Self::ScopedPackageWithKnope(name) => write!(
f,
"refusing to write scoped package `{name}` while knope.toml is present (quoted keys are invisible to knope)"
),
}
}
}
impl core::error::Error for WriteError {}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum KnopePresence {
Absent,
Present,
}
pub fn parse(text: &str) -> Result<ChangeFile, ParseError> {
parse_with(text, false)
}
pub fn parse_migration(text: &str) -> Result<ChangeFile, ParseError> {
parse_with(text, true)
}
fn parse_with(text: &str, allow_quoted_unscoped: bool) -> Result<ChangeFile, ParseError> {
if text.starts_with('\u{FEFF}') || text.as_bytes().starts_with(&[0xEF, 0xBB, 0xBF]) {
return Err(ParseError::Bom);
}
let mut lines = LineCursor::new(text);
let Some((_, first)) = lines.next_line() else {
return Err(ParseError::MissingOpeningDelimiter);
};
if first != "---" {
return Err(ParseError::MissingOpeningDelimiter);
}
let mut entries = Vec::new();
let mut seen = BTreeSet::new();
let mut closed_at = None;
while let Some((_, line)) = lines.next_line() {
if line == "---" {
closed_at = Some(lines.position_after_current_line());
break;
}
if line.trim().is_empty() {
return Err(ParseError::BlankLineInFrontmatter);
}
let (name, level) = parse_entry(line, allow_quoted_unscoped)?;
if !seen.insert(name.clone()) {
return Err(ParseError::DuplicatePackage(name));
}
entries.push((name, level));
}
let Some(note_start) = closed_at else {
return Err(ParseError::MissingClosingDelimiter);
};
Ok(ChangeFile {
entries,
note: String::from(&text[note_start..]),
})
}
pub fn write(
entries: &[(impl AsRef<str>, BumpLevel)],
note: &str,
knope: KnopePresence,
) -> Result<String, WriteError> {
let mut seen = BTreeSet::new();
let mut out = String::from("---\n");
for (name, level) in entries {
let name = name.as_ref();
validate_write_name(name)?;
if !seen.insert(String::from(name)) {
return Err(WriteError::DuplicatePackage(String::from(name)));
}
if is_scoped(name) {
if knope == KnopePresence::Present {
return Err(WriteError::ScopedPackageWithKnope(String::from(name)));
}
out.push('"');
out.push_str(name);
out.push('"');
} else {
out.push_str(name);
}
out.push_str(": ");
out.push_str(&level.to_string());
out.push('\n');
}
out.push_str("---\n");
out.push_str(note);
Ok(out)
}
fn validate_write_name(name: &str) -> Result<(), WriteError> {
if name.trim().is_empty() {
return Err(WriteError::EmptyPackageName);
}
if invalid_plain_key(name) {
return Err(WriteError::InvalidPackageName(String::from(name)));
}
Ok(())
}
pub(super) fn invalid_plain_key(name: &str) -> bool {
name != name.trim()
|| name.contains(['"', '\'', '\n', '\r', ':'])
|| yaml_plain_key_coerces(name)
}
fn yaml_plain_key_coerces(name: &str) -> bool {
matches!(
name,
"~" | "null"
| "Null"
| "NULL"
| "y"
| "Y"
| "n"
| "N"
| "yes"
| "Yes"
| "YES"
| "no"
| "No"
| "NO"
| "true"
| "True"
| "TRUE"
| "false"
| "False"
| "FALSE"
| "on"
| "On"
| "ON"
| "off"
| "Off"
| "OFF"
| ".inf"
| ".Inf"
| ".INF"
| "-.inf"
| "-.Inf"
| "-.INF"
| "+.inf"
| "+.Inf"
| "+.INF"
| ".nan"
| ".NaN"
| ".NAN"
) || yaml_integer_prefix(name)
|| yaml_decimal_or_float_coerces(name)
}
fn yaml_integer_prefix(name: &str) -> bool {
if let Some(digits) = name.strip_prefix("0x").or_else(|| name.strip_prefix("0X")) {
return !digits.is_empty() && digits.chars().all(|c| c.is_ascii_hexdigit());
}
if let Some(digits) = name.strip_prefix("0o").or_else(|| name.strip_prefix("0O")) {
return !digits.is_empty() && digits.chars().all(|c| matches!(c, '0'..='7'));
}
if let Some(digits) = name.strip_prefix("0b").or_else(|| name.strip_prefix("0B")) {
return !digits.is_empty() && digits.chars().all(|c| matches!(c, '0' | '1'));
}
false
}
fn yaml_decimal_or_float_coerces(name: &str) -> bool {
if let Some(rest) = name.strip_prefix('+') {
return yaml_numeric_body(rest);
}
let body = name.strip_prefix('-').unwrap_or(name);
if looks_like_yaml_float(body) {
return true;
}
(body == "0" && name != "0")
|| (body.len() > 1 && body.starts_with('0') && body.bytes().all(|b| b.is_ascii_digit()))
|| yaml_js_int_loses_precision(body)
}
fn yaml_js_int_loses_precision(body: &str) -> bool {
const MAX_SAFE: u64 = 9_007_199_254_740_991;
if body.is_empty() || !body.bytes().all(|b| b.is_ascii_digit()) {
return false;
}
match body.parse::<u64>() {
Ok(n) => n > MAX_SAFE,
Err(_) => true,
}
}
fn yaml_numeric_body(body: &str) -> bool {
!body.is_empty() && (looks_like_yaml_float(body) || body.bytes().all(|b| b.is_ascii_digit()))
}
fn looks_like_yaml_float(body: &str) -> bool {
let has_dot = body.contains('.');
let exp_at = body.find(['e', 'E']);
if !has_dot && exp_at.is_none() {
return false;
}
let (mantissa, exp_ok) = match exp_at {
Some(i) => {
let mantissa = &body[..i];
let mut exp = &body[i + 1..];
exp = exp.strip_prefix(['+', '-']).unwrap_or(exp);
if exp.is_empty() || !exp.bytes().all(|b| b.is_ascii_digit()) {
return false;
}
(mantissa, true)
}
None => (body, false),
};
if mantissa.is_empty() {
return false;
}
let Some((left, frac)) = mantissa.split_once('.') else {
return exp_ok && mantissa.bytes().all(|b| b.is_ascii_digit());
};
if left.is_empty() && frac.is_empty() {
return false;
}
left.bytes().all(|b| b.is_ascii_digit()) && frac.bytes().all(|b| b.is_ascii_digit())
}
fn is_scoped(name: &str) -> bool {
name.starts_with('@')
}
fn parse_entry(line: &str, allow_quoted_unscoped: bool) -> Result<(String, BumpLevel), ParseError> {
let Some((raw_key, raw_level)) = line.split_once(':') else {
return Err(ParseError::InvalidLine(String::from(line)));
};
if !raw_level.starts_with([' ', '\t']) {
return Err(ParseError::InvalidLine(String::from(line)));
}
let key = raw_key.trim();
let level_text = raw_level.trim();
if key.is_empty() || level_text.is_empty() {
return Err(ParseError::InvalidLine(String::from(line)));
}
let (name, quoted) = decode_package_key(key, line)?;
if name.is_empty() {
return Err(ParseError::InvalidLine(String::from(line)));
}
if is_scoped(name) {
if !quoted {
return Err(ParseError::UnquotedScopedName(String::from(name)));
}
} else if quoted && !allow_quoted_unscoped {
return Err(ParseError::QuotedUnscopedName(String::from(name)));
}
if validate_write_name(name).is_err() {
return Err(ParseError::InvalidLine(String::from(line)));
}
let level = BumpLevel::from_str(level_text)
.map_err(|err| ParseError::UnknownLevel(String::from(err.text())))?;
Ok((String::from(name), level))
}
fn decode_package_key<'a>(key: &'a str, line: &str) -> Result<(&'a str, bool), ParseError> {
let quote = match (key.contains('"'), key.contains('\'')) {
(false, false) => return Ok((key, false)),
(true, false) => b'"',
(false, true) => b'\'',
(true, true) => return Err(ParseError::InvalidLine(String::from(line))),
};
match strip_quotes(key, quote) {
Some(inner) if !inner.as_bytes().contains("e) => Ok((inner, true)),
_ => Err(ParseError::InvalidLine(String::from(line))),
}
}
fn strip_quotes(key: &str, quote: u8) -> Option<&str> {
let bytes = key.as_bytes();
if bytes.len() >= 2 && bytes[0] == quote && bytes[bytes.len() - 1] == quote {
Some(&key[1..key.len() - 1])
} else {
None
}
}
struct LineCursor<'a> {
text: &'a str,
pos: usize,
line_end: usize,
}
impl<'a> LineCursor<'a> {
fn new(text: &'a str) -> Self {
Self {
text,
pos: 0,
line_end: 0,
}
}
fn next_line(&mut self) -> Option<(usize, &'a str)> {
if self.pos > self.text.len() {
return None;
}
if self.pos == self.text.len() {
return None;
}
let start = self.pos;
let bytes = self.text.as_bytes();
let mut i = start;
while i < bytes.len() && bytes[i] != b'\n' {
i += 1;
}
let mut content_end = i;
if content_end > start && bytes[content_end - 1] == b'\r' {
content_end -= 1;
}
let content = &self.text[start..content_end];
self.line_end = if i < bytes.len() { i + 1 } else { bytes.len() };
self.pos = self.line_end;
Some((start, content))
}
fn position_after_current_line(&self) -> usize {
self.line_end
}
}
#[cfg(test)]
mod tests {
use super::*;
use alloc::string::ToString;
use alloc::vec;
#[test]
fn round_trips_unscoped_intersection_file() {
let body = "---\ncore: minor\nutils: patch\n---\n\nNotes here.\n";
let parsed = parse(body).expect("parse");
assert_eq!(
parsed.entries(),
&[
("core".to_string(), BumpLevel::Minor),
("utils".to_string(), BumpLevel::Patch),
]
);
assert_eq!(parsed.note(), "\nNotes here.\n");
let written = write(parsed.entries(), parsed.note(), KnopePresence::Absent).expect("write");
assert_eq!(written, body);
}
#[test]
fn accepts_crlf_and_keeps_note_bytes() {
let body = "---\r\ncore: major\r\n---\r\nbody\r\n";
let parsed = parse(body).expect("parse");
assert_eq!(parsed.entries(), &[("core".to_string(), BumpLevel::Major)]);
assert_eq!(parsed.note(), "body\r\n");
}
#[test]
fn writes_and_parses_quoted_scoped_name() {
let written = write(
&[("@oakum/core", BumpLevel::Minor)],
"note\n",
KnopePresence::Absent,
)
.expect("write");
assert_eq!(written, "---\n\"@oakum/core\": minor\n---\nnote\n");
let parsed = parse(&written).expect("parse");
assert_eq!(
parsed.entries(),
&[("@oakum/core".to_string(), BumpLevel::Minor)]
);
}
#[test]
fn refuses_scoped_write_when_knope_present() {
let err = write(
&[("@oakum/core", BumpLevel::Patch)],
"",
KnopePresence::Present,
)
.unwrap_err();
assert_eq!(
err,
WriteError::ScopedPackageWithKnope("@oakum/core".to_string())
);
}
#[test]
fn rejects_bom() {
assert_eq!(
parse("\u{FEFF}---\ncore: patch\n---\n"),
Err(ParseError::Bom)
);
}
#[test]
fn rejects_preamble() {
assert_eq!(
parse("preamble\n---\ncore: patch\n---\n"),
Err(ParseError::MissingOpeningDelimiter)
);
}
#[test]
fn rejects_blank_line_in_frontmatter() {
assert_eq!(
parse("---\ncore: patch\n\nutils: minor\n---\n"),
Err(ParseError::BlankLineInFrontmatter)
);
assert_eq!(
parse("---\ncore: patch\n \nutils: minor\n---\n"),
Err(ParseError::BlankLineInFrontmatter)
);
}
#[test]
fn rejects_duplicate_package() {
assert_eq!(
parse("---\ncore: patch\ncore: minor\n---\n"),
Err(ParseError::DuplicatePackage("core".to_string()))
);
}
#[test]
fn accepts_empty_frontmatter() {
let parsed = parse("---\n---\nnote\n").expect("empty");
assert_eq!(parsed.entries(), []);
assert_eq!(parsed.note(), "note\n");
}
#[test]
fn accepts_none_and_rejects_unknown_levels() {
let parsed = parse("---\ncore: none\n---\n").expect("none");
assert_eq!(parsed.entries(), &[("core".to_string(), BumpLevel::None)]);
assert_eq!(
parse("---\ncore: Major\n---\n"),
Err(ParseError::UnknownLevel("Major".to_string()))
);
}
#[test]
fn rejects_unquoted_scoped_and_quoted_unscoped() {
assert_eq!(
parse("---\n@oakum/core: minor\n---\n"),
Err(ParseError::UnquotedScopedName("@oakum/core".to_string()))
);
assert_eq!(
parse("---\n\"core\": minor\n---\n"),
Err(ParseError::QuotedUnscopedName("core".to_string()))
);
}
#[test]
fn parse_migration_accepts_quoted_unscoped_and_still_requires_quoted_scoped() {
let parsed = parse_migration("---\n\"core\": minor\n\"@oakum/cli\": patch\n---\nnote\n")
.expect("quoted changesets form");
assert_eq!(
parsed.entries(),
&[
("core".to_string(), BumpLevel::Minor),
("@oakum/cli".to_string(), BumpLevel::Patch),
]
);
let written = write(parsed.entries(), parsed.note(), KnopePresence::Absent).expect("write");
assert_eq!(
written,
"---\ncore: minor\n\"@oakum/cli\": patch\n---\nnote\n"
);
assert_eq!(
parse_migration("---\n@oakum/core: minor\n---\n"),
Err(ParseError::UnquotedScopedName("@oakum/core".to_string()))
);
assert_eq!(
parse_migration("---\n\" core \": patch\n---\n"),
Err(ParseError::InvalidLine("\" core \": patch".to_string()))
);
assert_eq!(
parse_migration("---\n\" \": patch\n---\n"),
Err(ParseError::InvalidLine("\" \": patch".to_string()))
);
}
#[test]
fn rejects_missing_closing_delimiter() {
assert_eq!(
parse("---\ncore: patch\n"),
Err(ParseError::MissingClosingDelimiter)
);
}
#[test]
fn write_empty_frontmatter_round_trips() {
let empty: Vec<(String, BumpLevel)> = vec![];
let body = write(&empty, "docs only\n", KnopePresence::Absent).expect("write");
assert_eq!(body, "---\n---\ndocs only\n");
let parsed = parse(&body).expect("parse");
assert_eq!(parsed.entries(), []);
assert_eq!(parsed.note(), "docs only\n");
}
#[test]
fn write_rejects_empty_and_illegal_names() {
assert_eq!(
write(&[("", BumpLevel::Patch)], "", KnopePresence::Absent),
Err(WriteError::EmptyPackageName)
);
assert_eq!(
write(&[(" ", BumpLevel::Patch)], "", KnopePresence::Absent),
Err(WriteError::EmptyPackageName)
);
assert_eq!(
write(
&[("core:extra", BumpLevel::Patch)],
"",
KnopePresence::Absent
),
Err(WriteError::InvalidPackageName("core:extra".to_string()))
);
assert_eq!(
write(&[("a\nb", BumpLevel::Patch)], "", KnopePresence::Absent),
Err(WriteError::InvalidPackageName("a\nb".to_string()))
);
assert_eq!(
write(
&[("\"core\"", BumpLevel::Patch)],
"",
KnopePresence::Present
),
Err(WriteError::InvalidPackageName("\"core\"".to_string()))
);
}
#[test]
fn write_rejects_yaml_renamed_keys() {
for name in [
"null",
"0x10",
"0o10",
"01",
"1.0",
"1e2",
"0777",
"-0",
"+1",
".5",
"True",
"TRUE",
"False",
"FALSE",
".inf",
"-.inf",
".nan",
"9007199254740993",
] {
assert_eq!(
write(&[(name, BumpLevel::Patch)], "", KnopePresence::Absent),
Err(WriteError::InvalidPackageName(name.to_string())),
"{name}"
);
}
}
#[test]
fn write_rejects_yaml_conservative_keys() {
for name in [
"yes",
"no",
"on",
"off",
"0X10",
"0b10",
"9007199254740992",
"9007199254740994",
] {
assert_eq!(
write(&[(name, BumpLevel::Patch)], "", KnopePresence::Absent),
Err(WriteError::InvalidPackageName(name.to_string())),
"{name}"
);
}
}
#[test]
fn write_keeps_names_that_only_resemble_yaml_tokens() {
for name in ["core", "yes-please", "on-call", "42"] {
write(&[(name, BumpLevel::Patch)], "n\n", KnopePresence::Absent).expect(name);
}
}
#[test]
fn write_rejects_duplicate_packages() {
assert_eq!(
write(
&[("core", BumpLevel::Patch), ("core", BumpLevel::Minor)],
"",
KnopePresence::Absent,
),
Err(WriteError::DuplicatePackage("core".to_string()))
);
}
#[test]
fn writes_unscoped_when_knope_present() {
let written =
write(&[("core", BumpLevel::Patch)], "n\n", KnopePresence::Present).expect("write");
assert_eq!(written, "---\ncore: patch\n---\nn\n");
assert_eq!(parse(&written).expect("parse").note(), "n\n");
}
#[test]
fn rejects_invalid_frontmatter_lines() {
assert_eq!(
parse("---\ncore patch\n---\n"),
Err(ParseError::InvalidLine("core patch".to_string()))
);
assert_eq!(
parse("---\n: patch\n---\n"),
Err(ParseError::InvalidLine(": patch".to_string()))
);
assert_eq!(
parse("---\ncore:\n---\n"),
Err(ParseError::InvalidLine("core:".to_string()))
);
assert_eq!(
parse("---\ncore:minor\n---\n"),
Err(ParseError::InvalidLine("core:minor".to_string()))
);
assert_eq!(
parse("---\n\"\": patch\n---\n"),
Err(ParseError::InvalidLine("\"\": patch".to_string()))
);
}
#[test]
fn rejects_malformed_quoting() {
assert_eq!(
parse("---\n\"core: patch\n---\n"),
Err(ParseError::InvalidLine("\"core: patch".to_string()))
);
assert_eq!(
parse("---\n'@oakum/core\": minor\n---\n"),
Err(ParseError::InvalidLine("'@oakum/core\": minor".to_string()))
);
assert_eq!(
parse("---\n\"@oakum/core: minor\n---\n"),
Err(ParseError::InvalidLine("\"@oakum/core: minor".to_string()))
);
}
#[test]
fn accepts_whitespace_around_key_and_level() {
let parsed = parse("---\n core : minor \n---\n").expect("parse");
assert_eq!(parsed.entries(), &[("core".to_string(), BumpLevel::Minor)]);
}
#[test]
fn round_trips_empty_note() {
let body = "---\ncore: patch\n---\n";
let parsed = parse(body).expect("parse");
assert_eq!(parsed.note(), "");
assert_eq!(
write(parsed.entries(), "", KnopePresence::Absent).expect("write"),
body
);
}
#[test]
fn every_bump_file_in_the_shipped_readme_parses() {
let readme = include_str!("../cli/changeset-readme.md");
let mut checked = 0;
for block in readme.split("```markdown").skip(1) {
let body = block.split("```").next().expect("a closing fence").trim();
if !body.starts_with("---") {
continue;
}
parse(&format!("{body}\n")).unwrap_or_else(|err| {
panic!(
"the shipped README documents a bump file this parser rejects: {err}\n{body}"
)
});
checked += 1;
}
assert!(checked >= 2, "found {checked} bump files in the README");
}
#[test]
fn a_quoted_bare_name_is_refused_and_says_why() {
let err = parse("---\n\"core\": minor\n---\n").expect_err("quoted bare name");
assert_eq!(
err.to_string(),
"package `core` must not be quoted (only scoped npm names are quoted)"
);
let single = parse("---\n'core': minor\n---\n").expect_err("single-quoted too");
assert_eq!(single.to_string(), err.to_string());
}
#[test]
fn single_quoted_scoped_name_parses_like_double_quoted() {
let single = parse("---\n'@oakum/core': minor\n---\n").expect("single");
let double = parse("---\n\"@oakum/core\": minor\n---\n").expect("double");
assert_eq!(single.entries(), double.entries());
assert_eq!(
single.entries(),
&[("@oakum/core".to_string(), BumpLevel::Minor)]
);
}
#[test]
fn single_quoted_unscoped_name_is_still_rejected() {
assert!(matches!(
parse("---\n'core': patch\n---\n"),
Err(ParseError::QuotedUnscopedName(name)) if name == "core"
));
assert!(matches!(
parse("---\n'@oakum/core\": patch\n---\n"),
Err(ParseError::InvalidLine(_))
));
}
}