Files
reqlite/crates/core/src/collection.rs
T

170 lines
5.2 KiB
Rust

//! A collection is a folder of `.http` files. Scanning builds the sidebar
//! tree (folder → file → requests), parses every file and reads the folder
//! settings ([`crate::folder`]).
use std::collections::BTreeMap;
use std::path::{Path, PathBuf};
use crate::folder::FolderSettings;
use crate::httpfile::HttpFile;
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum Node {
Folder {
name: String,
path: PathBuf,
children: Vec<Node>,
},
File {
name: String,
path: PathBuf,
},
}
impl Node {
pub fn name(&self) -> &str {
match self {
Node::Folder { name, .. } | Node::File { name, .. } => name,
}
}
pub fn path(&self) -> &Path {
match self {
Node::Folder { path, .. } | Node::File { path, .. } => path,
}
}
}
#[derive(Debug, Clone)]
pub struct Collection {
pub root: PathBuf,
pub tree: Node,
/// Parsed files by absolute path.
pub files: BTreeMap<PathBuf, HttpFile>,
/// Folder settings by folder path (only folders that have a file).
pub folders: BTreeMap<PathBuf, FolderSettings>,
/// Folder settings files that could not be read.
pub folder_errors: Vec<String>,
}
pub fn is_http_file(path: &Path) -> bool {
matches!(path.extension().and_then(|e| e.to_str()), Some("http" | "rest"))
}
fn skip_dir(name: &str) -> bool {
name.starts_with('.') || matches!(name, "node_modules" | "target")
}
/// Scans `root` recursively. Folders without `.http` files are left out.
pub fn scan(root: &Path) -> std::io::Result<Collection> {
let mut files = BTreeMap::new();
let mut folders = Folders::default();
let tree = scan_dir(root, &mut files, &mut folders)?.unwrap_or_else(|| Node::Folder {
name: dir_name(root),
path: root.to_path_buf(),
children: Vec::new(),
});
Ok(Collection {
root: root.to_path_buf(),
tree,
files,
folders: folders.settings,
folder_errors: folders.errors,
})
}
#[derive(Default)]
struct Folders {
settings: BTreeMap<PathBuf, FolderSettings>,
errors: Vec<String>,
}
fn dir_name(p: &Path) -> String {
p.file_name()
.map(|n| n.to_string_lossy().into_owned())
.unwrap_or_else(|| p.display().to_string())
}
fn scan_dir(
dir: &Path,
files: &mut BTreeMap<PathBuf, HttpFile>,
settings: &mut Folders,
) -> std::io::Result<Option<Node>> {
match FolderSettings::load(dir) {
Ok(Some(s)) => {
settings.settings.insert(dir.to_path_buf(), s);
}
Ok(None) => {}
Err(e) => settings.errors.push(e.to_string()),
}
let mut entries: Vec<_> = std::fs::read_dir(dir)?.filter_map(Result::ok).collect();
entries.sort_by_key(|e| e.file_name().to_string_lossy().to_lowercase());
let mut folders = Vec::new();
let mut leaves = Vec::new();
for e in entries {
let path = e.path();
let name = e.file_name().to_string_lossy().into_owned();
let Ok(ft) = e.file_type() else { continue };
if ft.is_dir() {
if skip_dir(&name) {
continue;
}
if let Some(n) = scan_dir(&path, files, settings)? {
folders.push(n);
}
} else if is_http_file(&path) {
let text = std::fs::read_to_string(&path)?;
files.insert(path.clone(), HttpFile::parse(text));
leaves.push(Node::File { name, path });
}
}
if folders.is_empty() && leaves.is_empty() {
return Ok(None);
}
folders.extend(leaves);
Ok(Some(Node::Folder {
name: dir_name(dir),
path: dir.to_path_buf(),
children: folders,
}))
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn scans_folders_files_and_requests() {
let dir = tempfile::tempdir().unwrap();
let root = dir.path();
std::fs::write(
root.join("users.http"),
"### List\nGET /users\n\n### Get\nGET /users/1\n",
)
.unwrap();
std::fs::create_dir_all(root.join("orders/payloads")).unwrap();
std::fs::write(root.join("orders/create.http"), "POST /orders\n").unwrap();
std::fs::write(root.join("orders/payloads/order.json"), "{}").unwrap();
std::fs::create_dir(root.join(".git")).unwrap();
std::fs::write(root.join(".git/x.http"), "GET /").unwrap();
std::fs::create_dir(root.join("empty")).unwrap();
std::fs::create_dir_all(root.join("orders/.reqlite")).unwrap();
std::fs::write(root.join("orders/.reqlite/folder.json"), r#"{"auth": "Bearer x"}"#).unwrap();
let c = scan(root).unwrap();
let Node::Folder { children, .. } = &c.tree else {
panic!()
};
let names: Vec<&str> = children.iter().map(Node::name).collect();
assert_eq!(names, vec!["orders", "users.http"]);
let Node::Folder { children: orders, .. } = &children[0] else {
panic!()
};
assert_eq!(orders.len(), 1);
assert_eq!(c.files.len(), 2);
assert_eq!(c.files[&root.join("users.http")].request_count(), 2);
assert_eq!(c.folders.keys().collect::<Vec<_>>(), vec![&root.join("orders")]);
assert!(c.folder_errors.is_empty());
}
}