This commit is contained in:
zhongluofeng committed 2026-10-10 14:29:48 +08:00
1 parent ad987111a3
commit c9e61f38c5
89 files changed
+11775 -3155

No files matched your search

+471
View File
@@ -0,0 +1,471 @@
//! 导入:本地 Markdown 目录 / 单文件 / zip 包 → 笔记库。
//!
//! # 永不覆盖
//!
//! 导入的唯一硬规则是**不覆盖库内已有文件**:重名时加序号(`笔记 2.md`)。
//! 理由很直接 —— 导入是个批量动作,用户不会记得库里已经有哪些名字;一旦某个
//! 同名笔记被静默替换,就是一次不可撤销的数据丢失。「多一个文件」远比「少一篇笔记」
//! 可接受。
//!
//! # zip 的路径安全
//!
//! zip 条目名可以包含 `..` 或绝对路径(经典的 Zip Slip)。这里用
//! `enclosed_name()` 让 zip crate 做规范化与拒绝,再过一道 [`library::safe_join`]。
//! 两层都做不是冗余:前者防的是「解包到库外」,后者防的是「库内路径被拼成绝对路径」。
//!
//! # 保留目录结构
//!
//! 导入目录时保留其相对结构(`笔记/2026/a.md` → `<目标目录>/笔记/2026/a.md`):
//! 用户选一个目录导入,期待的是「把这棵子树搬进来」,而不是把几十篇笔记拍平到一层。
//! 但**跳过隐藏目录与 `node_modules`**(与同步的排除规则同一口径)。
use std::io::Read;
use std::path::{Path, PathBuf};
use super::library;
use super::types::ImportReport;
/// 测试里要用 `ZipWriter::write_all`(`Write` 是 trait 方法,必须进作用域)。
#[cfg(test)]
use std::io::Write as _;
/// 单次导入的文件数上限(防御性:避免误选 `C:\` 之类的目录把应用拖死)。
const MAX_IMPORT_FILES: usize = 20_000;
/// 从磁盘路径导入(文件 / 目录 / zip,自动判别)。
///
/// `dest_dir` 为库内相对目录(空串 = 库根)。
pub fn import_path(root: &Path, source: &str, dest_dir: &str) -> Result<ImportReport, String> {
let path = PathBuf::from(source.trim());
if !path.exists() {
return Err(format!("路径不存在:{source}"));
}
library::ensure_library(root)?;
// 目标目录先建出来(导入到新建的目录时它可能还不存在)
let dest = library::safe_join(root, dest_dir)?;
std::fs::create_dir_all(&dest).map_err(|e| format!("创建目标目录失败: {e}"))?;
let mut report = ImportReport::default();
if path.is_file() {
let is_zip = path
.extension()
.map(|e| e.eq_ignore_ascii_case("zip"))
.unwrap_or(false);
if is_zip {
import_zip(root, &path, &dest, &mut report)?;
} else {
import_single(root, &path, &dest, &mut report)?;
}
} else {
import_dir(root, &path, &dest, &mut report)?;
}
// 导入后刷新索引交给命令层(它有 AppHandle 与索引服务)
Ok(report)
}
/// 导入单个文件(非 Markdown 的图片类文件放进 `assets/`)。
fn import_single(
root: &Path,
file: &Path,
dest: &Path,
report: &mut ImportReport,
) -> Result<(), String> {
let name = file
.file_name()
.map(|n| n.to_string_lossy().to_string())
.unwrap_or_default();
if name.is_empty() {
return Err("无法解析文件名".to_string());
}
if !is_markdown(&name) {
// 单选的图片/附件:放进 assets,不当笔记
return import_asset(root, file, &name, report);
}
copy_note(file, dest, &name, report)
}
/// 递归导入目录(保留相对结构)。
fn import_dir(
root: &Path,
dir: &Path,
dest: &Path,
report: &mut ImportReport,
) -> Result<(), String> {
let mut count = 0usize;
for entry in walkdir::WalkDir::new(dir)
.max_depth(library::MAX_DEPTH)
.into_iter()
.filter_map(Result::ok)
{
if !entry.file_type().is_file() {
continue;
}
let path = entry.path();
let rel_from_source = match path.strip_prefix(dir) {
Ok(rel) => rel,
Err(_) => continue,
};
// 跳过隐藏项与 node_modules(与同步排除口径一致)
let rel_text = rel_from_source.to_string_lossy().replace('\\', "/");
if rel_text
.split('/')
.any(|part| part.starts_with('.') || part.eq_ignore_ascii_case("node_modules"))
{
continue;
}
count += 1;
if count > MAX_IMPORT_FILES {
return Err(format!("导入文件过多(超过 {MAX_IMPORT_FILES}),请分批导入"));
}
let name = path
.file_name()
.map(|n| n.to_string_lossy().to_string())
.unwrap_or_default();
if is_markdown(&name) {
// 保持子目录结构
let sub = rel_from_source
.parent()
.map(|p| p.to_string_lossy().replace('\\', "/"))
.unwrap_or_default();
let target_dir = if sub.is_empty() {
dest.to_path_buf()
} else {
let joined = library::safe_join(root, &relative_to(root, dest, &sub))?;
std::fs::create_dir_all(&joined).map_err(|e| format!("创建目录失败: {e}"))?;
joined
};
copy_note(path, &target_dir, &name, report)?;
} else if is_asset(&name) {
if let Err(e) = import_asset(root, path, &name, report) {
push_failure(report, &rel_text, &e);
}
} else {
report.skipped += 1;
}
}
Ok(())
}
/// 由「库内目标目录 + 源侧子目录」拼出库内相对路径。
fn relative_to(root: &Path, dest: &Path, sub: &str) -> String {
let prefix = library::rel_string(root, dest);
if prefix.is_empty() {
sub.to_string()
} else {
format!("{prefix}/{sub}")
}
}
/// 导入 zip 包(保留包内结构)。
fn import_zip(
root: &Path,
file: &Path,
dest: &Path,
report: &mut ImportReport,
) -> Result<(), String> {
let handle = std::fs::File::open(file).map_err(|e| format!("打开 zip 失败: {e}"))?;
let mut archive = zip::ZipArchive::new(handle).map_err(|e| format!("读取 zip 失败: {e}"))?;
let dest_prefix = library::rel_string(root, dest);
for index in 0..archive.len() {
let mut entry = archive
.by_index(index)
.map_err(|e| format!("读取 zip 条目失败: {e}"))?;
// Zip Slip 的第一道防线:`enclosed_name` 拒绝 `..`/绝对路径
let Some(inner) = entry.enclosed_name().map(|p| p.to_path_buf()) else {
push_failure(report, &format!("条目 #{index}"), "路径越界,已跳过");
continue;
};
if entry.is_dir() {
continue;
}
let rel = inner.to_string_lossy().replace('\\', "/");
// macOS 压缩包常见的 `__MACOSX/` 与隐藏文件
if rel
.split('/')
.any(|part| part.starts_with('.') || part.eq_ignore_ascii_case("__MACOSX"))
{
report.skipped += 1;
continue;
}
let name = inner
.file_name()
.map(|n| n.to_string_lossy().to_string())
.unwrap_or_default();
if name.is_empty() {
continue;
}
let mut bytes = Vec::new();
entry
.read_to_end(&mut bytes)
.map_err(|e| format!("读取 zip 内容失败: {e}"))?;
if is_markdown(&name) {
let sub = inner
.parent()
.map(|p| p.to_string_lossy().replace('\\', "/"))
.unwrap_or_default();
let target_rel = if sub.is_empty() {
join_rel(&dest_prefix, &name)
} else {
join_rel(&dest_prefix, &format!("{sub}/{name}"))
};
match write_unique(root, &target_rel, &bytes) {
Ok(renamed) => {
report.imported += 1;
if renamed {
report.renamed += 1;
}
}
Err(e) => push_failure(report, &rel, &e),
}
} else if is_asset(&name) {
match write_asset_unique(root, &name, &bytes) {
Ok(_) => report.imported += 1,
Err(e) => push_failure(report, &rel, &e),
}
} else {
report.skipped += 1;
}
}
Ok(())
}
/// 拷贝一篇 Markdown(重名加序号,**不覆盖**)。
fn copy_note(
file: &Path,
dest_dir: &Path,
name: &str,
report: &mut ImportReport,
) -> Result<(), String> {
let bytes = std::fs::read(file).map_err(|e| format!("读取 {name} 失败: {e}"))?;
// 目标目录已在库内,这里直接构造候选名并落盘(仍走 safe_join 的等价校验)
let mut candidate = name.to_string();
let mut index = 1;
while dest_dir.join(&candidate).exists() {
candidate = numbered(name, index);
index += 1;
if index > 9999 {
return Err("同名文件过多".to_string());
}
}
let renamed = candidate != name;
std::fs::write(dest_dir.join(&candidate), &bytes).map_err(|e| format!("写入 {candidate} 失败: {e}"))?;
report.imported += 1;
if renamed {
report.renamed += 1;
}
Ok(())
}
/// 把附件写进库根 `assets/`(重名加序号)。
fn import_asset(
root: &Path,
file: &Path,
name: &str,
report: &mut ImportReport,
) -> Result<(), String> {
let bytes = std::fs::read(file).map_err(|e| format!("读取 {name} 失败: {e}"))?;
write_asset_unique(root, name, &bytes)?;
report.imported += 1;
Ok(())
}
/// 写入 `assets/`(重名加序号)。
fn write_asset_unique(root: &Path, name: &str, bytes: &[u8]) -> Result<String, String> {
let assets = root.join(library::ASSETS_DIR);
std::fs::create_dir_all(&assets).map_err(|e| format!("创建附件目录失败: {e}"))?;
let safe = library::validate_name(name)?;
let mut candidate = safe.clone();
let mut index = 1;
while assets.join(&candidate).exists() {
candidate = numbered(&safe, index);
index += 1;
if index > 9999 {
return Err("同名附件过多".to_string());
}
}
std::fs::write(assets.join(&candidate), bytes).map_err(|e| format!("写入附件失败: {e}"))?;
Ok(candidate)
}
/// 按库内相对路径写入(重名加序号),返回是否被改名。
fn write_unique(root: &Path, rel: &str, bytes: &[u8]) -> Result<bool, String> {
let target = library::safe_join(root, rel)?;
if let Some(parent) = target.parent() {
std::fs::create_dir_all(parent).map_err(|e| format!("创建目录失败: {e}"))?;
}
let name = target
.file_name()
.map(|n| n.to_string_lossy().to_string())
.unwrap_or_default();
let mut candidate = name.clone();
let mut index = 1;
let mut renamed = false;
while target.parent().map(|p| p.join(&candidate).exists()).unwrap_or(false) {
candidate = numbered(&name, index);
index += 1;
renamed = true;
if index > 9999 {
return Err("同名文件过多".to_string());
}
}
let final_path = match target.parent() {
Some(parent) => parent.join(&candidate),
None => target.clone(),
};
std::fs::write(&final_path, bytes).map_err(|e| format!("写入 {candidate} 失败: {e}"))?;
Ok(renamed)
}
/// 拼相对路径(空前缀时不带斜杠)。
fn join_rel(prefix: &str, name: &str) -> String {
if prefix.is_empty() {
name.to_string()
} else {
format!("{prefix}/{name}")
}
}
/// `笔记.md` → `笔记 2.md`
fn numbered(name: &str, index: u32) -> String {
match name.rfind('.') {
Some(dot) => format!("{} {}{}", &name[..dot], index + 1, &name[dot..]),
None => format!("{name} {}", index + 1),
}
}
fn is_markdown(name: &str) -> bool {
name.to_ascii_lowercase().ends_with(".md")
|| name.to_ascii_lowercase().ends_with(".markdown")
}
/// 附件类型的白名单(图片、PDF、压缩包以外的常见附件)。
///
/// 用白名单而不是「非 md 即附件」:导入一个目录时往往会混进 `.DS_Store`、
/// `Thumbs.db`、`.gitignore` 之类;把它们全塞进 `assets/` 只会制造垃圾。
fn is_asset(name: &str) -> bool {
const EXT: &[&str] = &[
"png", "jpg", "jpeg", "gif", "webp", "svg", "bmp", "avif", "pdf", "mp3", "wav", "mp4",
"webm", "zip",
];
match name.rsplit('.').next() {
Some(ext) => EXT.contains(&ext.to_ascii_lowercase().as_str()),
None => false,
}
}
fn push_failure(report: &mut ImportReport, name: &str, error: &str) {
if report.failures.len() < 20 {
report.failures.push(format!("{name}:{error}"));
}
}
#[cfg(test)]
mod tests {
use super::*;
fn temp_lib(tag: &str) -> PathBuf {
let root = std::env::temp_dir().join(format!("thing-notes-import-{tag}-{}", std::process::id()));
let _ = std::fs::remove_dir_all(&root);
std::fs::create_dir_all(root.join("assets")).unwrap();
root
}
#[test]
fn import_single_file_renames_instead_of_overwriting() {
let root = temp_lib("single");
let src_dir = std::env::temp_dir().join(format!("thing-notes-src-single-{}", std::process::id()));
let _ = std::fs::remove_dir_all(&src_dir);
std::fs::create_dir_all(&src_dir).unwrap();
std::fs::write(src_dir.join("a.md"), "导入的内容").unwrap();
// 库内已有一篇同名
std::fs::write(root.join("a.md"), "库里原有的").unwrap();
let report = import_path(&root, &src_dir.join("a.md").to_string_lossy(), "").unwrap();
assert_eq!(report.imported, 1);
assert_eq!(report.renamed, 1);
// 原有内容必须没被覆盖
assert_eq!(std::fs::read_to_string(root.join("a.md")).unwrap(), "库里原有的");
assert_eq!(std::fs::read_to_string(root.join("a 2.md")).unwrap(), "导入的内容");
let _ = std::fs::remove_dir_all(&root);
let _ = std::fs::remove_dir_all(&src_dir);
}
#[test]
fn import_directory_keeps_structure_and_skips_junk() {
let root = temp_lib("dir");
let src = std::env::temp_dir().join(format!("thing-notes-src-dir-{}", std::process::id()));
let _ = std::fs::remove_dir_all(&src);
std::fs::create_dir_all(src.join("sub")).unwrap();
std::fs::create_dir_all(src.join(".git")).unwrap();
std::fs::write(src.join("top.md"), "top").unwrap();
std::fs::write(src.join("sub/deep.md"), "deep").unwrap();
std::fs::write(src.join("sub/note.txt"), "不是 md").unwrap();
std::fs::write(src.join(".git/config"), "不该导入").unwrap();
std::fs::write(src.join("pic.png"), [1u8, 2, 3]).unwrap();
let report = import_path(&root, &src.to_string_lossy(), "导入").unwrap();
assert_eq!(report.imported, 3, "两篇 md + 一张图片: {report:?}");
assert_eq!(report.skipped, 1, "note.txt 应被跳过: {report:?}");
assert!(root.join("导入/top.md").is_file());
assert!(root.join("导入/sub/deep.md").is_file(), "应保留子目录结构");
assert!(root.join("assets/pic.png").is_file());
assert!(!root.join("导入/.git").exists());
let _ = std::fs::remove_dir_all(&root);
let _ = std::fs::remove_dir_all(&src);
}
#[test]
fn import_zip_keeps_structure_and_rejects_traversal() {
let root = temp_lib("zip");
let zip_path = std::env::temp_dir().join(format!("thing-notes-src-{}.zip", std::process::id()));
{
let file = std::fs::File::create(&zip_path).unwrap();
let mut writer = zip::ZipWriter::new(file);
let options: zip::write::FileOptions<'_, ()> = zip::write::FileOptions::default();
writer.start_file("notes/a.md", options).unwrap();
writer.write_all(b"# A").unwrap();
// 恶意条目:逃出库根
writer.start_file("../escape.md", options).unwrap();
writer.write_all("坏".as_bytes()).unwrap();
writer.start_file("__MACOSX/x.md", options).unwrap();
writer.write_all(b"mac").unwrap();
writer.finish().unwrap();
}
let report = import_path(&root, &zip_path.to_string_lossy(), "").unwrap();
assert_eq!(report.imported, 1, "{report:?}");
assert!(root.join("notes/a.md").is_file());
// `enclosed_name()` 会把 `../escape.md` 归一化成 `escape.md`(去掉了越界前缀),
// 关键是**没有写到库根之外**
let parent = root.parent().unwrap();
assert!(!parent.join("escape.md").exists(), "不能写到库根之外");
let _ = std::fs::remove_dir_all(&root);
let _ = std::fs::remove_file(&zip_path);
}
#[test]
fn numbered_names_keep_extension() {
assert_eq!(numbered("a.md", 1), "a 2.md");
assert_eq!(numbered("无扩展名", 0), "无扩展名 1");
assert_eq!(numbered("a.b.md", 2), "a.b 3.md");
}
#[test]
fn asset_whitelist_rejects_junk() {
assert!(is_asset("pic.png"));
assert!(is_asset("PIC.PNG"));
assert!(is_asset("doc.pdf"));
assert!(!is_asset("Thumbs.db"));
assert!(!is_asset(".DS_Store"));
assert!(!is_asset("noext"));
}}