89d0e39ad2
* feat: add template field to type entries and template-aware note creation - Rust: add template field to Frontmatter, VaultEntry, SKIP_KEYS - Rust: support YAML block scalar (|) for multi-line strings in frontmatter - Rust: fix value continuation detection to handle block scalars properly - TypeScript: add template to VaultEntry, buildNewEntry, frontmatterToEntryPatch - Add DEFAULT_TEMPLATES for Project, Person, Responsibility, Experiment - resolveNewNote/buildNoteContent accept optional template parameter - handleCreateNote and handleCreateNoteImmediate look up type template - Tests for all new behavior (Rust + TypeScript) Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com> * feat: wire template UI through Sidebar and App, add TypeCustomizePopover template section - Add template textarea with debounced save to TypeCustomizePopover - Wire handleUpdateTypeTemplate through useEntryActions → Sidebar → App - Add useDebouncedCallback hook for 500ms template save debounce - Add tests for handleUpdateTypeTemplate and TypeCustomizePopover template UI - Create design/note-templates.pen placeholder Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com> * fix: useRef type arg + template field in bulk mock entries * style: rustfmt --------- Co-authored-by: Test <test@test.com> Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com> Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>
828 lines
26 KiB
Rust
828 lines
26 KiB
Rust
use serde::{Deserialize, Serialize};
|
|
use std::fs;
|
|
use std::path::Path;
|
|
|
|
/// Value type for frontmatter updates
|
|
#[derive(Debug, Serialize, Deserialize, Clone)]
|
|
#[serde(untagged)]
|
|
pub enum FrontmatterValue {
|
|
String(String),
|
|
Number(f64),
|
|
Bool(bool),
|
|
List(Vec<String>),
|
|
Null,
|
|
}
|
|
|
|
/// Characters that require a YAML string value to be quoted.
|
|
fn has_yaml_special_chars(s: &str) -> bool {
|
|
s.contains(':') || s.contains('#')
|
|
}
|
|
|
|
/// Check if a string starts with a YAML collection indicator (array or map).
|
|
fn starts_as_yaml_collection(s: &str) -> bool {
|
|
s.starts_with('[') || s.starts_with('{')
|
|
}
|
|
|
|
/// Check whether a YAML string value needs quoting to avoid ambiguity.
|
|
fn needs_yaml_quoting(s: &str) -> bool {
|
|
has_yaml_special_chars(s)
|
|
|| starts_as_yaml_collection(s)
|
|
|| matches!(s, "true" | "false" | "null")
|
|
|| s.parse::<f64>().is_ok()
|
|
}
|
|
|
|
/// Quote a string value for YAML, escaping internal double quotes.
|
|
fn quote_yaml_string(s: &str) -> String {
|
|
format!("\"{}\"", s.replace('\"', "\\\""))
|
|
}
|
|
|
|
/// Format a single YAML list item as ` - "value"`.
|
|
fn format_list_item(item: &str) -> String {
|
|
format!(" - {}", quote_yaml_string(item))
|
|
}
|
|
|
|
/// Format a multi-line string as a YAML block scalar (`|`).
|
|
/// Each line is indented by 2 spaces; empty lines are preserved as blank.
|
|
fn format_block_scalar(s: &str) -> String {
|
|
let indented = s
|
|
.lines()
|
|
.map(|l| {
|
|
if l.is_empty() {
|
|
String::new()
|
|
} else {
|
|
format!(" {}", l)
|
|
}
|
|
})
|
|
.collect::<Vec<_>>()
|
|
.join("\n");
|
|
format!("|\n{}", indented)
|
|
}
|
|
|
|
/// Format a number for YAML (integers without decimal, floats with).
|
|
fn format_yaml_number(n: f64) -> String {
|
|
if n.fract() == 0.0 {
|
|
format!("{}", n as i64)
|
|
} else {
|
|
format!("{}", n)
|
|
}
|
|
}
|
|
|
|
impl FrontmatterValue {
|
|
pub fn to_yaml_value(&self) -> String {
|
|
match self {
|
|
FrontmatterValue::String(s) => {
|
|
if s.contains('\n') {
|
|
format_block_scalar(s)
|
|
} else if needs_yaml_quoting(s) {
|
|
quote_yaml_string(s)
|
|
} else {
|
|
s.clone()
|
|
}
|
|
}
|
|
FrontmatterValue::Number(n) => format_yaml_number(*n),
|
|
FrontmatterValue::Bool(b) => if *b { "true" } else { "false" }.to_string(),
|
|
FrontmatterValue::List(items) if items.is_empty() => "[]".to_string(),
|
|
FrontmatterValue::List(items) => items
|
|
.iter()
|
|
.map(|item| format_list_item(item))
|
|
.collect::<Vec<_>>()
|
|
.join("\n"),
|
|
FrontmatterValue::Null => "null".to_string(),
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Check whether a YAML key needs quoting (contains spaces, special chars, etc.).
|
|
fn needs_key_quoting(key: &str) -> bool {
|
|
key.chars()
|
|
.any(|c| !c.is_ascii_alphanumeric() && c != '_' && c != '-')
|
|
}
|
|
|
|
/// Format a key for YAML output (quote if necessary)
|
|
pub fn format_yaml_key(key: &str) -> String {
|
|
if needs_key_quoting(key) {
|
|
format!("\"{}\"", key)
|
|
} else {
|
|
key.to_string()
|
|
}
|
|
}
|
|
|
|
/// Check if a line defines a specific key (handles quoted and unquoted keys)
|
|
fn line_is_key(line: &str, key: &str) -> bool {
|
|
let trimmed = line.trim_start();
|
|
|
|
if trimmed.starts_with(key) && trimmed[key.len()..].starts_with(':') {
|
|
return true;
|
|
}
|
|
|
|
let dq = format!("\"{}\":", key);
|
|
if trimmed.starts_with(&dq) {
|
|
return true;
|
|
}
|
|
|
|
let sq = format!("'{}\':", key);
|
|
if trimmed.starts_with(&sq) {
|
|
return true;
|
|
}
|
|
|
|
false
|
|
}
|
|
|
|
/// Format a key-value pair as one or more YAML lines.
|
|
fn format_yaml_field(key: &str, value: &FrontmatterValue) -> Vec<String> {
|
|
let yaml_key = format_yaml_key(key);
|
|
let yaml_value = value.to_yaml_value();
|
|
if yaml_value.starts_with("|\n") {
|
|
// Block scalar: key and indicator on the same line, content follows
|
|
vec![format!("{}: {}", yaml_key, yaml_value)]
|
|
} else if yaml_value.contains('\n') {
|
|
vec![format!("{}:", yaml_key), yaml_value]
|
|
} else {
|
|
vec![format!("{}: {}", yaml_key, yaml_value)]
|
|
}
|
|
}
|
|
|
|
/// Check if a line continues the previous key's value (indented list item,
|
|
/// block scalar content, or blank line inside a block scalar).
|
|
fn is_value_continuation(line: &str) -> bool {
|
|
line.is_empty() || line.starts_with(" ") || line.starts_with('\t')
|
|
}
|
|
|
|
/// Split content into frontmatter body and the rest after the closing `---`.
|
|
/// Returns `(fm_content, rest)` where `fm_content` is between the opening and closing `---`.
|
|
fn split_frontmatter(content: &str) -> Result<(&str, &str), String> {
|
|
let after_open = &content[4..];
|
|
// Handle empty frontmatter: closing --- immediately after opening ---\n
|
|
if let Some(stripped) = after_open.strip_prefix("---") {
|
|
return Ok(("", stripped));
|
|
}
|
|
let fm_end = after_open
|
|
.find("\n---")
|
|
.map(|i| i + 4)
|
|
.ok_or_else(|| "Malformed frontmatter: no closing ---".to_string())?;
|
|
Ok((&content[4..fm_end], &content[fm_end + 4..]))
|
|
}
|
|
|
|
/// Wrap content in a new frontmatter block containing a single field.
|
|
fn prepend_new_frontmatter(content: &str, key: &str, value: &FrontmatterValue) -> String {
|
|
let field_lines = format_yaml_field(key, value);
|
|
format!("---\n{}\n---\n{}", field_lines.join("\n"), content)
|
|
}
|
|
|
|
/// Apply a field update to existing frontmatter lines.
|
|
/// Replaces the matching key (and its list continuations) with the new value,
|
|
/// or appends if the key is not found. If `value` is None, removes the key.
|
|
fn apply_field_update(lines: &[&str], key: &str, value: Option<&FrontmatterValue>) -> Vec<String> {
|
|
let mut new_lines: Vec<String> = Vec::new();
|
|
let mut found_key = false;
|
|
let mut i = 0;
|
|
|
|
while i < lines.len() {
|
|
if !line_is_key(lines[i], key) {
|
|
new_lines.push(lines[i].to_string());
|
|
i += 1;
|
|
continue;
|
|
}
|
|
|
|
found_key = true;
|
|
i += 1;
|
|
// Skip continuation lines belonging to this key (lists, block scalars)
|
|
while i < lines.len() && is_value_continuation(lines[i]) {
|
|
i += 1;
|
|
}
|
|
// Insert replacement value (if any)
|
|
if let Some(v) = value {
|
|
new_lines.extend(format_yaml_field(key, v));
|
|
}
|
|
}
|
|
|
|
if let (false, Some(v)) = (found_key, value) {
|
|
new_lines.extend(format_yaml_field(key, v));
|
|
}
|
|
|
|
new_lines
|
|
}
|
|
|
|
/// Internal function to update frontmatter content
|
|
pub fn update_frontmatter_content(
|
|
content: &str,
|
|
key: &str,
|
|
value: Option<FrontmatterValue>,
|
|
) -> Result<String, String> {
|
|
if !content.starts_with("---\n") {
|
|
return match value {
|
|
Some(v) => Ok(prepend_new_frontmatter(content, key, &v)),
|
|
None => Ok(content.to_string()),
|
|
};
|
|
}
|
|
|
|
let (fm_content, rest) = split_frontmatter(content)?;
|
|
let lines: Vec<&str> = fm_content.lines().collect();
|
|
let new_lines = apply_field_update(&lines, key, value.as_ref());
|
|
let new_fm = new_lines.join("\n");
|
|
Ok(format!("---\n{}\n---{}", new_fm, rest))
|
|
}
|
|
|
|
/// Helper to read a file, apply a frontmatter transformation, and write back.
|
|
pub fn with_frontmatter<F>(path: &str, transform: F) -> Result<String, String>
|
|
where
|
|
F: FnOnce(&str) -> Result<String, String>,
|
|
{
|
|
let file_path = Path::new(path);
|
|
if !file_path.exists() {
|
|
return Err(format!("File does not exist: {}", path));
|
|
}
|
|
|
|
let content =
|
|
fs::read_to_string(file_path).map_err(|e| format!("Failed to read {}: {}", path, e))?;
|
|
|
|
let updated = transform(&content)?;
|
|
|
|
fs::write(file_path, &updated).map_err(|e| format!("Failed to write {}: {}", path, e))?;
|
|
|
|
Ok(updated)
|
|
}
|
|
|
|
/// Update a single frontmatter property in a markdown file.
|
|
pub fn update_frontmatter(
|
|
path: &str,
|
|
key: &str,
|
|
value: FrontmatterValue,
|
|
) -> Result<String, String> {
|
|
with_frontmatter(path, |content| {
|
|
update_frontmatter_content(content, key, Some(value.clone()))
|
|
})
|
|
}
|
|
|
|
/// Delete a frontmatter property from a markdown file.
|
|
pub fn delete_frontmatter_property(path: &str, key: &str) -> Result<String, String> {
|
|
with_frontmatter(path, |content| {
|
|
update_frontmatter_content(content, key, None)
|
|
})
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
|
|
#[test]
|
|
fn test_update_frontmatter_string() {
|
|
let content = "---\nStatus: Draft\n---\n# Test\n";
|
|
let updated = update_frontmatter_content(
|
|
content,
|
|
"Status",
|
|
Some(FrontmatterValue::String("Active".to_string())),
|
|
)
|
|
.unwrap();
|
|
assert!(updated.contains("Status: Active"));
|
|
assert!(!updated.contains("Status: Draft"));
|
|
}
|
|
|
|
#[test]
|
|
fn test_update_frontmatter_add_new_key() {
|
|
let content = "---\nStatus: Draft\n---\n# Test\n";
|
|
let updated = update_frontmatter_content(
|
|
content,
|
|
"Owner",
|
|
Some(FrontmatterValue::String("Luca".to_string())),
|
|
)
|
|
.unwrap();
|
|
assert!(updated.contains("Owner: Luca"));
|
|
assert!(updated.contains("Status: Draft"));
|
|
}
|
|
|
|
#[test]
|
|
fn test_update_frontmatter_quoted_key() {
|
|
let content = "---\n\"Is A\": Note\n---\n# Test\n";
|
|
let updated = update_frontmatter_content(
|
|
content,
|
|
"Is A",
|
|
Some(FrontmatterValue::String("Project".to_string())),
|
|
)
|
|
.unwrap();
|
|
assert!(updated.contains("\"Is A\": Project"));
|
|
assert!(!updated.contains("Note"));
|
|
}
|
|
|
|
#[test]
|
|
fn test_update_frontmatter_list() {
|
|
let content = "---\nStatus: Draft\n---\n# Test\n";
|
|
let updated = update_frontmatter_content(
|
|
content,
|
|
"aliases",
|
|
Some(FrontmatterValue::List(vec![
|
|
"Alias1".to_string(),
|
|
"Alias2".to_string(),
|
|
])),
|
|
)
|
|
.unwrap();
|
|
assert!(updated.contains("aliases:"));
|
|
assert!(updated.contains(" - \"Alias1\""));
|
|
assert!(updated.contains(" - \"Alias2\""));
|
|
}
|
|
|
|
#[test]
|
|
fn test_update_frontmatter_replace_list() {
|
|
let content = "---\naliases:\n - Old1\n - Old2\nStatus: Draft\n---\n# Test\n";
|
|
let updated = update_frontmatter_content(
|
|
content,
|
|
"aliases",
|
|
Some(FrontmatterValue::List(vec!["New1".to_string()])),
|
|
)
|
|
.unwrap();
|
|
assert!(updated.contains(" - \"New1\""));
|
|
assert!(!updated.contains("Old1"));
|
|
assert!(!updated.contains("Old2"));
|
|
assert!(updated.contains("Status: Draft"));
|
|
}
|
|
|
|
#[test]
|
|
fn test_delete_frontmatter_property() {
|
|
let content = "---\nStatus: Draft\nOwner: Luca\n---\n# Test\n";
|
|
let updated = update_frontmatter_content(content, "Owner", None).unwrap();
|
|
assert!(!updated.contains("Owner"));
|
|
assert!(updated.contains("Status: Draft"));
|
|
}
|
|
|
|
#[test]
|
|
fn test_delete_frontmatter_list_property() {
|
|
let content = "---\naliases:\n - Alias1\n - Alias2\nStatus: Draft\n---\n# Test\n";
|
|
let updated = update_frontmatter_content(content, "aliases", None).unwrap();
|
|
assert!(!updated.contains("aliases"));
|
|
assert!(!updated.contains("Alias1"));
|
|
assert!(updated.contains("Status: Draft"));
|
|
}
|
|
|
|
#[test]
|
|
fn test_update_frontmatter_no_existing() {
|
|
let content = "# Test\n\nSome content here.";
|
|
let updated = update_frontmatter_content(
|
|
content,
|
|
"Status",
|
|
Some(FrontmatterValue::String("Draft".to_string())),
|
|
)
|
|
.unwrap();
|
|
assert!(updated.starts_with("---\n"));
|
|
assert!(updated.contains("Status: Draft"));
|
|
assert!(updated.contains("# Test"));
|
|
}
|
|
|
|
#[test]
|
|
fn test_update_frontmatter_bool() {
|
|
let content = "---\nStatus: Draft\n---\n# Test\n";
|
|
let updated =
|
|
update_frontmatter_content(content, "Reviewed", Some(FrontmatterValue::Bool(true)))
|
|
.unwrap();
|
|
assert!(updated.contains("Reviewed: true"));
|
|
}
|
|
|
|
#[test]
|
|
fn test_format_yaml_key_simple() {
|
|
assert_eq!(format_yaml_key("Status"), "Status");
|
|
assert_eq!(format_yaml_key("is_a"), "is_a");
|
|
}
|
|
|
|
#[test]
|
|
fn test_format_yaml_key_with_spaces() {
|
|
assert_eq!(format_yaml_key("Is A"), "\"Is A\"");
|
|
assert_eq!(format_yaml_key("Created at"), "\"Created at\"");
|
|
}
|
|
|
|
// --- to_yaml_value quoting tests ---
|
|
|
|
#[test]
|
|
fn test_to_yaml_value_string_needs_quoting_colon() {
|
|
let v = FrontmatterValue::String("key: value".to_string());
|
|
assert_eq!(v.to_yaml_value(), "\"key: value\"");
|
|
}
|
|
|
|
#[test]
|
|
fn test_to_yaml_value_string_needs_quoting_hash() {
|
|
let v = FrontmatterValue::String("has # comment".to_string());
|
|
assert_eq!(v.to_yaml_value(), "\"has # comment\"");
|
|
}
|
|
|
|
#[test]
|
|
fn test_to_yaml_value_string_needs_quoting_bracket() {
|
|
let v = FrontmatterValue::String("[array-like]".to_string());
|
|
assert_eq!(v.to_yaml_value(), "\"[array-like]\"");
|
|
}
|
|
|
|
#[test]
|
|
fn test_to_yaml_value_string_needs_quoting_brace() {
|
|
let v = FrontmatterValue::String("{object-like}".to_string());
|
|
assert_eq!(v.to_yaml_value(), "\"{object-like}\"");
|
|
}
|
|
|
|
#[test]
|
|
fn test_to_yaml_value_string_needs_quoting_bool_like() {
|
|
assert_eq!(
|
|
FrontmatterValue::String("true".to_string()).to_yaml_value(),
|
|
"\"true\""
|
|
);
|
|
assert_eq!(
|
|
FrontmatterValue::String("false".to_string()).to_yaml_value(),
|
|
"\"false\""
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_to_yaml_value_string_needs_quoting_null_like() {
|
|
assert_eq!(
|
|
FrontmatterValue::String("null".to_string()).to_yaml_value(),
|
|
"\"null\""
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_to_yaml_value_string_needs_quoting_number_like() {
|
|
assert_eq!(
|
|
FrontmatterValue::String("42".to_string()).to_yaml_value(),
|
|
"\"42\""
|
|
);
|
|
assert_eq!(
|
|
FrontmatterValue::String("3.14".to_string()).to_yaml_value(),
|
|
"\"3.14\""
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_to_yaml_value_string_plain() {
|
|
let v = FrontmatterValue::String("Hello World".to_string());
|
|
assert_eq!(v.to_yaml_value(), "Hello World");
|
|
}
|
|
|
|
#[test]
|
|
fn test_to_yaml_value_number_integer() {
|
|
let v = FrontmatterValue::Number(42.0);
|
|
assert_eq!(v.to_yaml_value(), "42");
|
|
}
|
|
|
|
#[test]
|
|
fn test_to_yaml_value_number_float() {
|
|
let v = FrontmatterValue::Number(3.14);
|
|
assert_eq!(v.to_yaml_value(), "3.14");
|
|
}
|
|
|
|
#[test]
|
|
fn test_to_yaml_value_null() {
|
|
assert_eq!(FrontmatterValue::Null.to_yaml_value(), "null");
|
|
}
|
|
|
|
#[test]
|
|
fn test_to_yaml_value_empty_list() {
|
|
let v = FrontmatterValue::List(vec![]);
|
|
assert_eq!(v.to_yaml_value(), "[]");
|
|
}
|
|
|
|
#[test]
|
|
fn test_to_yaml_value_list_with_colon() {
|
|
let v = FrontmatterValue::List(vec!["key: value".to_string()]);
|
|
assert_eq!(v.to_yaml_value(), " - \"key: value\"");
|
|
}
|
|
|
|
// --- update_frontmatter_content additional type tests ---
|
|
|
|
#[test]
|
|
fn test_update_frontmatter_number() {
|
|
let content = "---\nStatus: Draft\n---\n# Test\n";
|
|
let updated =
|
|
update_frontmatter_content(content, "Priority", Some(FrontmatterValue::Number(5.0)))
|
|
.unwrap();
|
|
assert!(updated.contains("Priority: 5"));
|
|
}
|
|
|
|
#[test]
|
|
fn test_update_frontmatter_number_float() {
|
|
let content = "---\nStatus: Draft\n---\n# Test\n";
|
|
let updated =
|
|
update_frontmatter_content(content, "Score", Some(FrontmatterValue::Number(9.5)))
|
|
.unwrap();
|
|
assert!(updated.contains("Score: 9.5"));
|
|
}
|
|
|
|
#[test]
|
|
fn test_update_frontmatter_null() {
|
|
let content = "---\nStatus: Draft\n---\n# Test\n";
|
|
let updated =
|
|
update_frontmatter_content(content, "ClearMe", Some(FrontmatterValue::Null)).unwrap();
|
|
assert!(updated.contains("ClearMe: null"));
|
|
}
|
|
|
|
#[test]
|
|
fn test_update_frontmatter_empty_list() {
|
|
let content = "---\nStatus: Draft\n---\n# Test\n";
|
|
let updated =
|
|
update_frontmatter_content(content, "tags", Some(FrontmatterValue::List(vec![])))
|
|
.unwrap();
|
|
assert!(updated.contains("tags: []"));
|
|
}
|
|
|
|
#[test]
|
|
fn test_update_frontmatter_malformed_no_closing_fence() {
|
|
let content = "---\nStatus: Draft\nNo closing fence here";
|
|
let result = update_frontmatter_content(
|
|
content,
|
|
"Status",
|
|
Some(FrontmatterValue::String("Active".to_string())),
|
|
);
|
|
assert!(result.is_err());
|
|
assert!(result.unwrap_err().contains("Malformed frontmatter"));
|
|
}
|
|
|
|
// --- delete non-existent key (should be no-op) ---
|
|
|
|
#[test]
|
|
fn test_delete_nonexistent_key_noop() {
|
|
let content = "---\nStatus: Draft\n---\n# Test\n";
|
|
let updated = update_frontmatter_content(content, "NonExistent", None).unwrap();
|
|
assert_eq!(updated, content);
|
|
}
|
|
|
|
#[test]
|
|
fn test_delete_from_no_frontmatter_noop() {
|
|
let content = "# Test\n\nSome content.";
|
|
let updated = update_frontmatter_content(content, "NonExistent", None).unwrap();
|
|
assert_eq!(updated, content);
|
|
}
|
|
|
|
// --- line_is_key tests ---
|
|
|
|
#[test]
|
|
fn test_line_is_key_unquoted() {
|
|
assert!(line_is_key("Status: Draft", "Status"));
|
|
assert!(!line_is_key("Status: Draft", "Owner"));
|
|
}
|
|
|
|
#[test]
|
|
fn test_line_is_key_double_quoted() {
|
|
assert!(line_is_key("\"Is A\": Note", "Is A"));
|
|
assert!(!line_is_key("\"Is A\": Note", "Status"));
|
|
}
|
|
|
|
#[test]
|
|
fn test_line_is_key_single_quoted() {
|
|
assert!(line_is_key("'Is A': Note", "Is A"));
|
|
}
|
|
|
|
#[test]
|
|
fn test_line_is_key_leading_whitespace() {
|
|
assert!(line_is_key(" Status: Draft", "Status"));
|
|
}
|
|
|
|
#[test]
|
|
fn test_line_is_key_partial_match() {
|
|
// "StatusBar" should not match key "Status"
|
|
assert!(!line_is_key("StatusBar: value", "Status"));
|
|
}
|
|
|
|
// --- with_frontmatter error cases ---
|
|
|
|
#[test]
|
|
fn test_with_frontmatter_file_not_found() {
|
|
let result = with_frontmatter("/nonexistent/path/file.md", |c| Ok(c.to_string()));
|
|
assert!(result.is_err());
|
|
assert!(result.unwrap_err().contains("does not exist"));
|
|
}
|
|
|
|
// --- roundtrip tests ---
|
|
|
|
#[test]
|
|
fn test_roundtrip_update_string() {
|
|
let content = "---\nStatus: Draft\n---\n# Test\n";
|
|
let updated = update_frontmatter_content(
|
|
content,
|
|
"Status",
|
|
Some(FrontmatterValue::String("Active".to_string())),
|
|
)
|
|
.unwrap();
|
|
// Parse back with gray_matter
|
|
let matter = gray_matter::Matter::<gray_matter::engine::YAML>::new();
|
|
let parsed = matter.parse(&updated);
|
|
let data = parsed.data.unwrap();
|
|
if let gray_matter::Pod::Hash(map) = data {
|
|
assert_eq!(map.get("Status").unwrap().as_string().unwrap(), "Active");
|
|
} else {
|
|
panic!("Expected hash");
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn test_roundtrip_update_list() {
|
|
let content = "---\nStatus: Draft\n---\n# Test\n";
|
|
let updated = update_frontmatter_content(
|
|
content,
|
|
"aliases",
|
|
Some(FrontmatterValue::List(vec![
|
|
"A".to_string(),
|
|
"B".to_string(),
|
|
])),
|
|
)
|
|
.unwrap();
|
|
let matter = gray_matter::Matter::<gray_matter::engine::YAML>::new();
|
|
let parsed = matter.parse(&updated);
|
|
let data = parsed.data.unwrap();
|
|
if let gray_matter::Pod::Hash(map) = data {
|
|
let aliases = map.get("aliases").unwrap();
|
|
if let gray_matter::Pod::Array(arr) = aliases {
|
|
assert_eq!(arr.len(), 2);
|
|
assert_eq!(arr[0].as_string().unwrap(), "A");
|
|
assert_eq!(arr[1].as_string().unwrap(), "B");
|
|
} else {
|
|
panic!("Expected array");
|
|
}
|
|
} else {
|
|
panic!("Expected hash");
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn test_roundtrip_add_then_delete() {
|
|
let content = "---\nStatus: Draft\n---\n# Test\n";
|
|
let with_owner = update_frontmatter_content(
|
|
content,
|
|
"Owner",
|
|
Some(FrontmatterValue::String("Luca".to_string())),
|
|
)
|
|
.unwrap();
|
|
assert!(with_owner.contains("Owner: Luca"));
|
|
let without_owner = update_frontmatter_content(&with_owner, "Owner", None).unwrap();
|
|
assert!(!without_owner.contains("Owner"));
|
|
assert!(without_owner.contains("Status: Draft"));
|
|
}
|
|
|
|
// --- format_yaml_key additional tests ---
|
|
|
|
#[test]
|
|
fn test_format_yaml_key_with_colon() {
|
|
assert_eq!(format_yaml_key("key:value"), "\"key:value\"");
|
|
}
|
|
|
|
#[test]
|
|
fn test_format_yaml_key_with_hash() {
|
|
assert_eq!(format_yaml_key("has#tag"), "\"has#tag\"");
|
|
}
|
|
|
|
#[test]
|
|
fn test_format_yaml_key_with_period() {
|
|
assert_eq!(format_yaml_key("key.name"), "\"key.name\"");
|
|
}
|
|
|
|
// --- split_frontmatter / empty frontmatter edge cases ---
|
|
|
|
#[test]
|
|
fn test_split_frontmatter_empty_block() {
|
|
// ---\n---\n (no fields between opening and closing ---)
|
|
let result = split_frontmatter("---\n---\n");
|
|
assert!(
|
|
result.is_ok(),
|
|
"split_frontmatter should handle empty frontmatter block"
|
|
);
|
|
let (fm, rest) = result.unwrap();
|
|
assert_eq!(fm, "");
|
|
assert_eq!(rest, "\n");
|
|
}
|
|
|
|
#[test]
|
|
fn test_split_frontmatter_empty_block_no_trailing_newline() {
|
|
// ---\n--- (no trailing newline)
|
|
let result = split_frontmatter("---\n---");
|
|
assert!(
|
|
result.is_ok(),
|
|
"split_frontmatter should handle empty frontmatter without trailing newline"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_split_frontmatter_empty_block_with_body() {
|
|
// ---\n---\n\n# Title\n
|
|
let result = split_frontmatter("---\n---\n\n# Title\n");
|
|
assert!(
|
|
result.is_ok(),
|
|
"split_frontmatter should handle empty frontmatter with body"
|
|
);
|
|
let (fm, rest) = result.unwrap();
|
|
assert_eq!(fm, "");
|
|
assert!(rest.contains("# Title"));
|
|
}
|
|
|
|
#[test]
|
|
fn test_update_frontmatter_empty_block() {
|
|
let content = "---\n---\n\n# Test\n";
|
|
let result = update_frontmatter_content(
|
|
content,
|
|
"title",
|
|
Some(FrontmatterValue::String("New Title".to_string())),
|
|
);
|
|
assert!(
|
|
result.is_ok(),
|
|
"update_frontmatter_content should handle empty frontmatter block"
|
|
);
|
|
let updated = result.unwrap();
|
|
assert!(updated.contains("title: New Title"));
|
|
}
|
|
|
|
// --- block scalar (multi-line string) tests ---
|
|
|
|
#[test]
|
|
fn test_to_yaml_value_multiline_uses_block_scalar() {
|
|
let v = FrontmatterValue::String("line 1\nline 2\nline 3".to_string());
|
|
let yaml = v.to_yaml_value();
|
|
assert!(yaml.starts_with("|\n"));
|
|
assert!(yaml.contains(" line 1"));
|
|
assert!(yaml.contains(" line 2"));
|
|
}
|
|
|
|
#[test]
|
|
fn test_format_yaml_field_block_scalar() {
|
|
let v = FrontmatterValue::String("## Objective\n\n## Timeline".to_string());
|
|
let lines = format_yaml_field("template", &v);
|
|
assert_eq!(lines.len(), 1);
|
|
assert!(lines[0].starts_with("template: |\n"));
|
|
assert!(lines[0].contains(" ## Objective"));
|
|
assert!(lines[0].contains(" ## Timeline"));
|
|
}
|
|
|
|
#[test]
|
|
fn test_update_frontmatter_block_scalar_add() {
|
|
let content = "---\ntype: Type\n---\n# Project\n";
|
|
let template = "## Objective\n\n## Timeline";
|
|
let updated = update_frontmatter_content(
|
|
content,
|
|
"template",
|
|
Some(FrontmatterValue::String(template.to_string())),
|
|
)
|
|
.unwrap();
|
|
assert!(updated.contains("template: |"));
|
|
assert!(updated.contains(" ## Objective"));
|
|
assert!(updated.contains(" ## Timeline"));
|
|
assert!(updated.contains("type: Type"));
|
|
}
|
|
|
|
#[test]
|
|
fn test_update_frontmatter_block_scalar_replace() {
|
|
let content = "---\ntype: Type\ntemplate: |\n ## Old\n \n ## Stuff\ncolor: green\n---\n# Project\n";
|
|
let new_template = "## New\n\n## Content";
|
|
let updated = update_frontmatter_content(
|
|
content,
|
|
"template",
|
|
Some(FrontmatterValue::String(new_template.to_string())),
|
|
)
|
|
.unwrap();
|
|
assert!(updated.contains(" ## New"));
|
|
assert!(updated.contains(" ## Content"));
|
|
assert!(!updated.contains("## Old"));
|
|
assert!(!updated.contains("## Stuff"));
|
|
assert!(updated.contains("color: green"));
|
|
}
|
|
|
|
#[test]
|
|
fn test_delete_frontmatter_block_scalar() {
|
|
let content =
|
|
"---\ntype: Type\ntemplate: |\n ## Heading\n \n ## Body\ncolor: green\n---\n# Project\n";
|
|
let updated = update_frontmatter_content(content, "template", None).unwrap();
|
|
assert!(!updated.contains("template"));
|
|
assert!(!updated.contains("## Heading"));
|
|
assert!(updated.contains("color: green"));
|
|
}
|
|
|
|
#[test]
|
|
fn test_roundtrip_block_scalar() {
|
|
let content = "---\ntype: Type\n---\n# Project\n";
|
|
let template = "## Objective\n\nDescribe the goal.\n\n## Timeline\n\nKey dates.";
|
|
let updated = update_frontmatter_content(
|
|
content,
|
|
"template",
|
|
Some(FrontmatterValue::String(template.to_string())),
|
|
)
|
|
.unwrap();
|
|
// Parse back with gray_matter
|
|
let matter = gray_matter::Matter::<gray_matter::engine::YAML>::new();
|
|
let parsed = matter.parse(&updated);
|
|
let data = parsed.data.unwrap();
|
|
if let gray_matter::Pod::Hash(map) = data {
|
|
let roundtripped = map.get("template").unwrap().as_string().unwrap();
|
|
assert!(roundtripped.contains("## Objective"));
|
|
assert!(roundtripped.contains("## Timeline"));
|
|
assert!(roundtripped.contains("Describe the goal."));
|
|
} else {
|
|
panic!("Expected hash");
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn test_update_frontmatter_no_body_after_closing() {
|
|
// Frontmatter with title, no body after closing ---
|
|
let content = "---\ntitle: Old\n---\n";
|
|
let result = update_frontmatter_content(
|
|
content,
|
|
"title",
|
|
Some(FrontmatterValue::String("New".to_string())),
|
|
);
|
|
assert!(result.is_ok());
|
|
let updated = result.unwrap();
|
|
assert!(updated.contains("title: New"));
|
|
assert!(!updated.contains("title: Old"));
|
|
}
|
|
}
|