Sergio
53dbdf0f1d
Workspace en 4 ejes (core/modules/apps/shared):
- core/: 24 crates de arje (Init systemd-compatible: ente-card, ente-zero,
ente-kernel, ente-bus, ente-cas, ente-soma, ente-wasm, ente-snapshot,
ente-brain, ente-echo, ente-policy-provider, + 12 crates *-compat)
- modules/semantic_dht/: 5 crates de minga (minga-core con AST/CAS/MST,
minga-p2p con libp2p Kad, minga-store, minga-vfs, minga-cli)
- modules/ui_engine/: 11 crates de yahweh (libs/{core,theme,bus,providers},
widgets/{tree,splitter,tabs,tiled,container_core,text_input})
- apps/: 5 crates de yahweh (file_explorer, database_explorer, text_viewer,
image_viewer, yahweh-shell)
- shared_wit/protocol.wit: handshake/lifecycle inicial
Cargo.toml unificado: thiserror bumped a 2 (transparente para arje), tokio
"full", paths intra-workspace de yahweh redirigidos a su nueva ubicación.
cargo check --workspace: 0 errores, 17 warnings (dead code preexistente).
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
68 lines
2.0 KiB
Rust
68 lines
2.0 KiB
Rust
//! Provider de filesystem local. Crate puro: cero dependencia de UI.
|
|
//! Implementa `yahweh_core::DataProvider` listando hijos de un path con
|
|
//! `std::fs::read_dir` y leyendo archivos a `Vec<u8>` via `tokio::io`.
|
|
|
|
use async_trait::async_trait;
|
|
use std::fs;
|
|
use std::io::Cursor;
|
|
use std::path::Path;
|
|
use std::pin::Pin;
|
|
use tokio::io::{AsyncRead, AsyncWrite};
|
|
use yahweh_core::{DataProvider, DisplayType, EntityNode};
|
|
|
|
pub const PROVIDER_ID: &str = "local_fs";
|
|
|
|
pub struct FileDataProvider;
|
|
|
|
#[async_trait]
|
|
impl DataProvider for FileDataProvider {
|
|
fn provider_id(&self) -> String {
|
|
PROVIDER_ID.to_string()
|
|
}
|
|
|
|
async fn list_children(&self, parent_id: Option<&str>) -> Result<Vec<EntityNode>, String> {
|
|
let path = parent_id.unwrap_or(".");
|
|
let mut children = Vec::new();
|
|
|
|
if let Ok(entries) = fs::read_dir(path) {
|
|
for entry in entries.filter_map(|e| e.ok()) {
|
|
let path = entry.path();
|
|
let name = path
|
|
.file_name()
|
|
.unwrap_or_default()
|
|
.to_string_lossy()
|
|
.into_owned();
|
|
let display_type = if path.is_dir() {
|
|
DisplayType::Folder
|
|
} else {
|
|
DisplayType::File
|
|
};
|
|
|
|
children.push(EntityNode {
|
|
id: path.to_string_lossy().into_owned(),
|
|
name,
|
|
display_type,
|
|
mime_type: None,
|
|
});
|
|
}
|
|
}
|
|
|
|
Ok(children)
|
|
}
|
|
|
|
async fn get_read_stream(
|
|
&self,
|
|
entity_id: &str,
|
|
) -> Result<Pin<Box<dyn AsyncRead + Send>>, String> {
|
|
let content = fs::read(Path::new(entity_id)).map_err(|e| e.to_string())?;
|
|
Ok(Box::pin(Cursor::new(content)))
|
|
}
|
|
|
|
async fn get_write_stream(
|
|
&self,
|
|
_entity_id: &str,
|
|
) -> Result<Pin<Box<dyn AsyncWrite + Send>>, String> {
|
|
Err("Escritura en streaming no implementada para FS".to_string())
|
|
}
|
|
}
|