use std::path::{Path, PathBuf};
use crate::error::NbError;
const TEXT_EXTENSIONS: &[&str] = &[
"adoc", "asciidoc", "bash", "bib", "coffee", "css", "go", "html", "js",
"json", "jsx", "latex", "markdown", "md", "mdown", "mdwn", "mdtxt",
"mdtext", "mkd", "mkdn", "org", "py", "rb", "Rmd", "rst", "scss", "sh",
"sql", "tex", "text", "textile", "ts", "tsx", "txt", "xml",
];
const ARCHIVE_EXTENSIONS: &[&str] = &[
"7z",
"apk",
"bz2",
"dmg",
"gz",
"lz",
"rar",
"s7z",
"sit",
"sitx",
"sparsebundle",
"tar",
"tgz",
"tbz2",
"tlz",
"txz",
"xz",
"zip",
"zipx",
"Z",
];
const AUDIO_EXTENSIONS: &[&str] =
&["aac", "aiff", "flac", "m4a", "mp3", "ogg", "wav"];
const DOCUMENT_EXTENSIONS: &[&str] =
&["doc", "docx", "odt", "pdf", "rtf", "xls", "xlsx"];
const ENCRYPTED_EXTENSIONS: &[&str] = &["enc"];
const IMAGE_EXTENSIONS: &[&str] = &[
"afphoto", "ai", "bmp", "gif", "heic", "ind", "indd", "jpg", "jpeg",
"png", "psd", "raw", "svg", "svgz", "tif", "tiff", "webp",
];
const VIDEO_EXTENSIONS: &[&str] = &[
"avi", "flv", "m4p", "m4v", "mp2", "mp4", "mov", "mpeg", "mpg", "qt",
"webm", "wmv",
];
pub(crate) enum NativeClass {
Text,
NonTextual { ext: String },
Folder,
}
fn ext_after_last_dot(name: &str) -> &str {
match name.rfind('.') {
Some(i) => &name[i + 1..],
None => name,
}
}
fn ext_after_first_dot(name: &str) -> String {
match name.find('.') {
Some(i) => name[i + 1..].to_string(),
None => name.to_string(),
}
}
fn is_known_non_text(ext: &str) -> bool {
ARCHIVE_EXTENSIONS.contains(&ext)
|| AUDIO_EXTENSIONS.contains(&ext)
|| DOCUMENT_EXTENSIONS.contains(&ext)
|| ENCRYPTED_EXTENSIONS.contains(&ext)
|| IMAGE_EXTENSIONS.contains(&ext)
|| VIDEO_EXTENSIONS.contains(&ext)
}
fn magic_non_text(bytes: &[u8]) -> bool {
const MAGIC: &[&[u8]] = &[b"%PDF-", b"GIF87a", b"GIF89a", b"BZh", b"fLaC"];
MAGIC.iter().any(|m| bytes.starts_with(m))
|| (bytes.len() > 11
&& &bytes[0..4] == b"RIFF"
&& (&bytes[8..12] == b"WAVE" || &bytes[8..12] == b"WEBP"))
}
fn has_text_bom(bytes: &[u8]) -> bool {
bytes.starts_with(&[0xef, 0xbb, 0xbf])
|| bytes.starts_with(&[0xff, 0xfe])
|| bytes.starts_with(&[0xfe, 0xff])
|| bytes.starts_with(&[0x00, 0x00, 0xfe, 0xff])
|| bytes.starts_with(&[0xff, 0xfe, 0x00, 0x00])
}
fn is_text_bytes(bytes: &[u8]) -> bool {
if bytes.len() < 2 {
return false;
}
if has_text_bom(bytes) {
return true;
}
let has_newline = bytes.contains(&b'\n');
bytes.iter().all(|&b| {
b >= 0x80
|| b >= 0x20 && b != 0x7f
|| matches!(
b,
b'\t' | b'\n' | 0x0b | 0x0c | b'\r' | 0x07 | 0x08 | 0x1b
)
|| (b == 0x7f && !has_newline)
})
}
pub(crate) fn classify_bytes(rel: &str, bytes: &[u8]) -> NativeClass {
let first = ext_after_first_dot(rel);
let name = rel.rsplit('/').next().unwrap_or(rel);
let last = ext_after_last_dot(name);
if TEXT_EXTENSIONS.contains(&last) {
return NativeClass::Text;
}
if is_known_non_text(last) {
return NativeClass::NonTextual { ext: first };
}
if magic_non_text(bytes) || !is_text_bytes(bytes) {
return NativeClass::NonTextual { ext: first };
}
NativeClass::Text
}
pub(crate) fn classify_path(
abs: &Path,
rel: &str,
) -> Result<NativeClass, NbError> {
if abs.is_dir() {
return Ok(NativeClass::Folder);
}
let bytes = std::fs::read(abs).map_err(|e| NbError::Io {
path: abs.to_path_buf(),
source: e.into(),
})?;
Ok(classify_bytes(rel, &bytes))
}
pub(crate) fn numeric_id_for_rel(
notebook_root: &Path,
rel: &str,
) -> Result<Option<u32>, NbError> {
let (folder, basename) = match rel.rfind('/') {
Some(i) => (rel[..i].to_string(), rel[i + 1..].to_string()),
None => (String::new(), rel.to_string()),
};
let index_rel = if folder.is_empty() {
".index".to_string()
} else {
format!("{folder}/.index")
};
if !folder.is_empty() {
match ensure_no_symlink_prefix(notebook_root, &folder) {
Ok(()) => {},
Err(NbError::NotFound { .. }) => return Ok(None),
Err(e) => return Err(e),
}
}
if is_symlinked(notebook_root, &index_rel)? {
return Ok(None);
}
let abs = notebook_root.join(&index_rel);
let bytes = match std::fs::read(&abs) {
Ok(b) => b,
Err(e) if e.kind() == std::io::ErrorKind::NotFound => {
return Ok(None);
},
Err(e) => {
return Err(NbError::Io {
path: abs,
source: e.into(),
});
},
};
let text = String::from_utf8_lossy(&bytes);
let mut lines: Vec<&str> = text.split('\n').collect();
if text.ends_with('\n') {
lines.pop();
}
Ok(lines
.iter()
.position(|l| *l == basename)
.map(|p| p as u32 + 1))
}
pub(crate) fn canonical_selector(
notebook: &str,
notebook_root: &Path,
rel: &str,
) -> Result<String, NbError> {
let exact = format!("{notebook}:{rel}");
match numeric_id_for_rel(notebook_root, rel)? {
Some(id) => {
let folder = match rel.rfind('/') {
Some(i) => rel[..i].to_string(),
None => String::new(),
};
let candidate = if folder.is_empty() {
id.to_string()
} else {
format!("{folder}/{id}")
};
match resolve_selector(notebook_root, &candidate) {
Ok(back) if back == rel => {
Ok(format!("{notebook}:{candidate}"))
},
Ok(_) => Ok(exact),
Err(NbError::NotFound { .. }) => Ok(exact),
Err(e) => Err(e),
}
},
None => Ok(exact),
}
}
fn split_folder_id(input: &str) -> Option<(String, String)> {
if input.is_empty() {
return None;
}
match input.rfind('/') {
Some(i) => {
let (folder, id) = input.split_at(i);
let id = id.trim_start_matches('/');
if id.is_empty() {
None
} else {
Some((folder.to_string(), id.to_string()))
}
},
None => Some((String::new(), input.to_string())),
}
}
pub(crate) fn file_is_todo(rel: &str) -> bool {
let lower = rel.to_ascii_lowercase();
lower.ends_with("todo.md")
}
pub(crate) fn document_kind_for_rel(rel: &str) -> crate::DocumentKind {
let name = rel.rsplit('/').next().unwrap_or(rel);
let lower = name.to_ascii_lowercase();
if lower.ends_with(".todo.md") {
crate::DocumentKind::Todo
} else if lower.ends_with(".bookmark.md") {
crate::DocumentKind::Bookmark
} else {
crate::DocumentKind::Note
}
}
pub(crate) fn entity_kind_for_rel(
rel: &str,
class: &NativeClass,
) -> crate::EntityKind {
match class {
NativeClass::Folder => crate::EntityKind::Folder,
NativeClass::NonTextual { ext } => crate::EntityKind::Other {
reason: format!("non-textual:{ext}"),
},
NativeClass::Text => match document_kind_for_rel(rel) {
crate::DocumentKind::Note => crate::EntityKind::Note,
crate::DocumentKind::Todo => crate::EntityKind::Todo,
crate::DocumentKind::Bookmark => crate::EntityKind::Bookmark,
},
}
}
pub(crate) fn strip_checkbox(title: &str) -> &str {
match title.rfind("] ") {
Some(i) => &title[i + 2..],
None => title,
}
}
fn is_symlinked(notebook_root: &Path, rel: &str) -> Result<bool, NbError> {
let abs = notebook_root.join(rel);
match std::fs::symlink_metadata(&abs) {
Ok(meta) => Ok(meta.file_type().is_symlink()),
Err(e) if e.kind() == std::io::ErrorKind::NotFound => Ok(false),
Err(e) => Err(NbError::Io {
path: abs,
source: e.into(),
}),
}
}
pub(crate) fn ensure_no_symlink_prefix(
notebook_root: &Path,
folder: &str,
) -> Result<(), NbError> {
let mut prefix = PathBuf::new();
for component in folder.split('/') {
prefix.push(component);
let rel = prefix.to_string_lossy().into_owned();
match std::fs::symlink_metadata(notebook_root.join(&rel)) {
Ok(meta) if meta.file_type().is_symlink() => {
return Err(NbError::NotFound {
selector: folder.to_string(),
});
},
Ok(_) => {},
Err(e) if e.kind() == std::io::ErrorKind::NotFound => {},
Err(e) => {
return Err(NbError::Io {
path: notebook_root.join(&rel),
source: e.into(),
});
},
}
}
Ok(())
}
pub(crate) fn confine(input: &str) -> Option<String> {
if input.starts_with(['/', '\\']) {
return None;
}
let bytes = input.as_bytes();
if bytes.len() >= 2 && bytes[1] == b':' && bytes[0].is_ascii_alphabetic() {
return None;
}
#[cfg(windows)]
let normalized = input.replace('\\', "/");
#[cfg(windows)]
let input = normalized.as_str();
let mut parts: Vec<&str> = Vec::new();
for part in input.split('/') {
match part {
"" | "." => {},
".." => {
parts.pop()?;
},
_ => parts.push(part),
}
}
let rel = parts.join("/");
if rel.is_empty() {
return None;
}
Some(rel)
}
fn id_to_basename(
notebook_root: &Path,
folder: &str,
id: u32,
) -> Result<Option<String>, NbError> {
if id == 0 {
return Ok(None);
}
let rel = if folder.is_empty() {
".index".to_string()
} else {
format!("{folder}/.index")
};
if !folder.is_empty() {
match ensure_no_symlink_prefix(notebook_root, folder) {
Ok(()) => {},
Err(NbError::NotFound { .. }) => return Ok(None),
Err(e) => return Err(e),
}
}
if is_symlinked(notebook_root, &rel)? {
return Ok(None);
}
let abs = notebook_root.join(&rel);
let bytes = match std::fs::read(&abs) {
Ok(b) => b,
Err(e) if e.kind() == std::io::ErrorKind::NotFound => {
return Ok(None);
},
Err(e) => {
return Err(NbError::Io {
path: abs,
source: e.into(),
});
},
};
let text = String::from_utf8_lossy(&bytes);
let mut lines: Vec<&str> = text.split('\n').collect();
if text.ends_with('\n') {
lines.pop();
}
let basename = lines
.get(id as usize - 1)
.filter(|l| !l.is_empty())
.map(|l| l.to_string());
let Some(basename) = basename else {
return Ok(None);
};
if basename.contains('/') || basename.contains('\\') {
return Ok(None);
}
Ok(Some(basename))
}
fn strip_closing_hashes(line: &str) -> &str {
let t = line.trim_end_matches([' ', '\t']);
let hashes = t.len() - t.trim_end_matches('#').len();
if hashes == 0 {
return line;
}
let head = &t[..t.len() - hashes];
if head.ends_with([' ', '\t']) {
head.trim_end_matches([' ', '\t'])
} else {
line
}
}
pub(crate) fn has_nb_title_extension(name: &str) -> bool {
let lower = name.to_ascii_lowercase();
lower.ends_with(".md") || lower.ends_with(".markdown")
}
fn file_title(
notebook_root: &Path,
rel: &str,
) -> Result<Option<String>, NbError> {
let name = rel.rsplit('/').next().unwrap_or(rel);
if !has_nb_title_extension(name) {
return Ok(None);
}
let abs = notebook_root.join(rel);
let file = match std::fs::File::open(&abs) {
Ok(f) => f,
Err(e) if e.kind() == std::io::ErrorKind::NotFound => {
return Ok(None);
},
Err(e) => {
return Err(NbError::Io {
path: abs,
source: e.into(),
});
},
};
let mut scan = TitleScan::default();
let mut reader = std::io::BufReader::new(file);
let mut chunk = Vec::new();
loop {
chunk.clear();
let n = std::io::BufRead::read_until(&mut reader, b'\n', &mut chunk)
.map_err(|e| NbError::Io {
path: abs.clone(),
source: e.into(),
})?;
if n == 0 {
break;
}
if chunk.ends_with(b"\n") {
chunk.pop();
}
let line = String::from_utf8_lossy(&chunk);
let line = line.strip_suffix('\r').unwrap_or(&line);
if let Some(title) = scan.feed(line) {
return Ok(Some(title));
}
}
Ok(None)
}
#[derive(Default)]
struct TitleScan {
in_code: bool,
in_front: bool,
maybe: Option<String>,
}
impl TitleScan {
fn feed(&mut self, line: &str) -> Option<String> {
let bare = line.trim_start_matches([' ', '\t', '\u{b}', '\u{c}']);
if let Some(after_hash) = bare.strip_prefix('#')
&& !after_hash.starts_with('#')
&& !self.in_code
&& let Some(body) = after_hash.strip_prefix([' ', '\t'])
{
let body = body.trim_start_matches([' ', '\t']);
return Some(strip_closing_hashes(body).to_string());
}
if line == "---" {
self.in_front = !self.in_front;
} else if line.starts_with("```") {
self.in_code = !self.in_code;
} else if self.in_front && line.starts_with("title: ") {
return Some(line["title: ".len()..].to_string());
} else if !self.in_front && !self.in_code {
if self.maybe.is_none() && !line.is_empty() {
self.maybe = Some(line.to_string());
} else if let Some(candidate) = self.maybe.take() {
let underline = line.trim();
if !underline.is_empty() && underline.chars().all(|c| c == '=')
{
return Some(
candidate.trim_start_matches([' ', '\t']).to_string(),
);
}
self.maybe = Some(candidate);
}
}
None
}
}
pub(crate) fn title_of_bytes(rel: &str, bytes: &[u8]) -> Option<String> {
let name = rel.rsplit('/').next().unwrap_or(rel);
if !has_nb_title_extension(name) {
return None;
}
let mut scan = TitleScan::default();
let text = String::from_utf8_lossy(bytes);
for line in text.split('\n').map(|l| l.strip_suffix('\r').unwrap_or(l)) {
if let Some(title) = scan.feed(line) {
return Some(title);
}
}
None
}
fn root_scoped_files(notebook_root: &Path) -> Result<Vec<String>, NbError> {
let mut out = Vec::new();
let entries =
std::fs::read_dir(notebook_root).map_err(|e| NbError::Io {
path: notebook_root.to_path_buf(),
source: e.into(),
})?;
for entry in entries {
let entry = entry.map_err(|e| NbError::Io {
path: notebook_root.to_path_buf(),
source: e.into(),
})?;
let path = entry.path();
let file_type = entry.file_type().map_err(|e| NbError::Io {
path: path.clone(),
source: e.into(),
})?;
if file_type.is_symlink() || !file_type.is_file() {
continue;
}
let Some(name) = path.file_name().and_then(|s| s.to_str()) else {
continue;
};
if name.starts_with('.') {
continue;
}
out.push(name.to_string());
}
out.sort();
Ok(out)
}
pub(crate) fn resolve_exact(
notebook_root: &Path,
input: &str,
) -> Result<String, NbError> {
let rel = confine(input).filter(|r| !r.is_empty()).ok_or_else(|| {
NbError::NotFound {
selector: input.to_string(),
}
})?;
if let Some(i) = rel.rfind('/')
&& let Err(e) = ensure_no_symlink_prefix(notebook_root, &rel[..i])
{
return Err(match e {
NbError::NotFound { .. } => NbError::NotFound {
selector: input.to_string(),
},
other => other,
});
}
let abs = notebook_root.join(&rel);
match std::fs::symlink_metadata(&abs) {
Ok(meta) if meta.file_type().is_symlink() => Err(NbError::NotFound {
selector: input.to_string(),
}),
Ok(meta) if meta.is_file() || meta.is_dir() => Ok(rel),
Ok(_) => Err(NbError::NotFound {
selector: input.to_string(),
}),
Err(e) if e.kind() == std::io::ErrorKind::NotFound => {
Err(NbError::NotFound {
selector: input.to_string(),
})
},
Err(e) => Err(NbError::Io {
path: abs,
source: e.into(),
}),
}
}
pub(crate) fn confine_canonical(
root: &Path,
abs: &Path,
selector: &str,
) -> Result<PathBuf, NbError> {
let canonical_root = root.canonicalize().map_err(|e| NbError::Io {
path: root.to_path_buf(),
source: e.into(),
})?;
let canonical_abs = abs.canonicalize().map_err(|e| {
if e.kind() == std::io::ErrorKind::NotFound {
NbError::NotFound {
selector: selector.to_string(),
}
} else {
NbError::Io {
path: abs.to_path_buf(),
source: e.into(),
}
}
})?;
if canonical_abs.starts_with(&canonical_root) {
Ok(canonical_abs)
} else {
Err(NbError::NotFound {
selector: selector.to_string(),
})
}
}
pub(crate) fn resolve_selector(
notebook_root: &Path,
input: &str,
) -> Result<String, NbError> {
let Some(canonical) = confine(input) else {
return Err(NbError::NotFound {
selector: input.to_string(),
});
};
match resolve_exact(notebook_root, &canonical) {
Ok(rel) => return Ok(rel),
Err(NbError::NotFound { .. }) => {},
Err(other) => return Err(other),
}
let slashed = canonical.contains('/');
if let Some((folder, id_str)) = split_folder_id(&canonical)
&& let Ok(id) = id_str.parse::<u32>()
&& let Some(basename) = id_to_basename(notebook_root, &folder, id)?
{
let rel = if folder.is_empty() {
basename
} else {
format!("{folder}/{basename}")
};
match resolve_exact(notebook_root, &rel) {
Ok(verified) => return Ok(verified),
Err(NbError::NotFound { .. }) => {},
Err(other) => return Err(other),
}
}
if slashed {
return Err(NbError::NotFound {
selector: input.to_string(),
});
}
let mut titled = Vec::new();
for rel in root_scoped_files(notebook_root)? {
let title = file_title(notebook_root, &rel)?;
let exact = title.as_deref() == Some(canonical.as_str());
let checkbox = file_is_todo(&rel)
&& title.as_deref().map(strip_checkbox)
== Some(canonical.as_str());
if exact || checkbox {
titled.push(rel);
}
}
match titled.as_slice() {
[one] => return Ok(one.clone()),
[] => {},
_ => {
return Err(NbError::NotFound {
selector: input.to_string(),
});
},
}
Err(NbError::NotFound {
selector: input.to_string(),
})
}