use std::path::{Path, PathBuf};
use crate::error::Result;
pub(super) fn read_omf_input(path: Option<&Path>) -> Result<String> {
let raw = match path {
None => read_stdin_to_string()?,
Some(p) if p.as_os_str() == std::ffi::OsStr::new("-") => read_stdin_to_string()?,
Some(p) => std::fs::read_to_string(p).map_err(|e| {
crate::error::MemdError::ValidationError(format!("failed to read {}: {e}", p.display()))
})?,
};
if raw.trim().is_empty() {
return Err(crate::error::MemdError::ValidationError(
"OMF input is empty".to_string(),
));
}
Ok(raw)
}
pub(super) fn read_stdin_to_string() -> Result<String> {
use std::io::Read;
let mut buf = String::new();
std::io::stdin().read_to_string(&mut buf).map_err(|e| {
crate::error::MemdError::ValidationError(format!("failed to read stdin: {e}"))
})?;
Ok(buf)
}
pub(super) fn normalize_absolute(p: &Path) -> PathBuf {
use std::path::Component;
let abs = if p.is_absolute() {
p.to_path_buf()
} else {
std::env::current_dir()
.map(|cwd| cwd.join(p))
.unwrap_or_else(|_| p.to_path_buf())
};
let mut out = PathBuf::new();
for comp in abs.components() {
match comp {
Component::Prefix(_) | Component::RootDir => out.push(comp.as_os_str()),
Component::CurDir => {}
Component::ParentDir => {
out.pop();
}
Component::Normal(seg) => out.push(seg),
}
}
out
}
pub(super) fn path_is_inside(child: &Path, parent: &Path) -> bool {
#[cfg(windows)]
{
let c = child.to_string_lossy().to_lowercase();
let p = parent.to_string_lossy().to_lowercase();
Path::new(&c).starts_with(Path::new(&p))
}
#[cfg(not(windows))]
{
child.starts_with(parent)
}
}
pub(super) fn reject_if_any_symlink_inside_outdir(
full_target: &Path,
outdir_abs: &Path,
) -> Result<()> {
let rel = full_target.strip_prefix(outdir_abs).map_err(|_| {
crate::error::MemdError::ValidationError(format!(
"internal: target {} not inside outdir {}",
full_target.display(),
outdir_abs.display()
))
})?;
let mut current = outdir_abs.to_path_buf();
for segment in rel.components() {
current.push(segment.as_os_str());
match std::fs::symlink_metadata(¤t) {
Ok(meta) if meta.file_type().is_symlink() => {
return Err(crate::error::MemdError::ValidationError(format!(
"refusing to follow symlink inside outdir: {}",
current.display()
)));
}
Ok(_) => continue,
Err(e) if e.kind() == std::io::ErrorKind::NotFound => break,
Err(e) => {
return Err(crate::error::MemdError::ValidationError(format!(
"cannot verify symlink status for {}: {e}",
current.display()
)));
}
}
}
Ok(())
}
pub(super) fn absolutize_project_dir(path: &Path) -> Result<PathBuf> {
if path.is_absolute() {
return Ok(path.to_path_buf());
}
Ok(std::env::current_dir()?.join(path))
}
pub(super) fn resolve_data_dir(explicit: Option<&Path>) -> Result<PathBuf> {
if let Some(path) = explicit {
return Ok(normalize_absolute(path));
}
let home = dirs::home_dir().ok_or_else(|| {
crate::error::MemdError::StorageError("cannot resolve home directory".to_string())
})?;
Ok(home.join(".memd").join("data"))
}
pub(super) fn discover_project_data_dir_from(start: &Path) -> Option<PathBuf> {
let mut current: Option<&Path> = Some(start);
while let Some(dir) = current {
let scope_path = dir.join(".memd").join("tenant_scope.json");
if scope_path.is_file() {
if let Ok(text) = std::fs::read_to_string(&scope_path) {
if let Ok(value) = serde_json::from_str::<serde_json::Value>(&text) {
if let Some(raw) = value.get("data_dir").and_then(|v| v.as_str()) {
let candidate = PathBuf::from(raw);
return Some(if candidate.is_absolute() {
candidate
} else {
dir.join(candidate)
});
}
}
}
return None;
}
current = dir.parent();
}
None
}
pub(super) fn resolve_export_markdown_data_dirs_from(
explicit: Option<&Path>,
start_dir: Option<&Path>,
) -> Result<Vec<PathBuf>> {
if let Some(path) = explicit {
return Ok(vec![path.to_path_buf()]);
}
let mut candidates: Vec<PathBuf> = Vec::new();
if let Some(start) = start_dir {
if let Some(discovered) = discover_project_data_dir_from(start) {
candidates.push(discovered);
}
}
let home = dirs::home_dir().ok_or_else(|| {
crate::error::MemdError::StorageError("cannot resolve home directory".to_string())
})?;
let home_default = home.join(".memd").join("data");
if !candidates.contains(&home_default) {
candidates.push(home_default);
}
Ok(candidates)
}
pub(super) fn resolve_export_markdown_data_dirs(explicit: Option<&Path>) -> Result<Vec<PathBuf>> {
let cwd = std::env::current_dir().ok();
resolve_export_markdown_data_dirs_from(explicit, cwd.as_deref())
}