Files
Thing/src-tauri/src/editor/import.rs
T
2026-10-10 14:29:48 +08:00

472 lines
17 KiB
Rust
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
//! 导入:本地 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"));
}}