Parking bsvfs WIP experiment.

libbsv/Cargo.toml

@@ -9,5 +9,6 @@ license = "AGPL-3.0-or-later"
 toml = "0.5.8"
 camino = "1.0.7"
 regex = "1.6.0"
+bsvfs = { path = "../bsvfs" }
 cas-core = { path = "../cas-core" }
 cas-simple = { path = "../cas-simple" }

libbsv/src/lib.rs

@@ -18,10 +18,11 @@ extern crate toml;
 extern crate camino;
 extern crate regex;
 
+extern crate bsvfs;
 extern crate cas_core;
 
 
-mod permissions;
+// mod permissions;
 mod tree_item;
 mod tree_walker;
 // mod config;
@@ -30,7 +31,7 @@ mod ignore;
 mod repository;
 
 
-pub use crate::permissions::Permissions;
+// pub use crate::permissions::Permissions;
 pub use crate::tree_item::{Serialize, TreeItem};
 pub use crate::path_map::{PathMap, PathPair};
 pub use crate::repository::{Repository};

libbsv/src/permissions.rs

@@ -14,6 +14,7 @@
 // along with bsv.  If not, see <https://www.gnu.org/licenses/>.
 
 
+use bsvfs::{Metadata};
 use cas_core::{err, Error, Result};
 
 
@@ -25,24 +26,12 @@ pub struct Permissions {
 }
 
 impl Permissions {
-    #[cfg(not(unix))]
-    pub fn from_metadata(metadata: &std::fs::Metadata) -> Result<Self> {
-        if metadata.permissions().readonly() {
-            Ok(Permissions::READ_ONLY)
-        }
-        else {
-            Ok(Permission::READ_WRITE)
-        }
-    }
-
-    #[cfg(unix)]
-    pub fn from_metadata(metadata: &std::fs::Metadata) -> Result<Self> {
-        use std::os::unix::fs::MetadataExt;
-        let mode = metadata.mode();
+    pub fn from_metadata<M: Metadata>(metadata: &M) -> Result<Self> {
+        let permissions = metadata.permissions();
         Ok(Self {
-            read: mode & 0o100 != 0,
-            write: mode & 0o200 != 0,
-            execute: mode & 0o400 != 0,
+            read: permissions.is_read(),
+            write: permissions.is_write(),
+            execute: permissions.is_execute(),
         })
     }
 

libbsv/src/repository.rs

@@ -20,7 +20,6 @@ use toml::Value;
 use cas_core::{Cas, err, Error, ObjectId, Result};
 use cas_simple::{SimpleCas};
 
-pub use crate::permissions::Permissions;
 pub use crate::tree_item::{Serialize, TreeItem};
 
 

libbsv/src/tree_item.rs

@@ -17,10 +17,9 @@
 use std::time::{Duration, SystemTime, UNIX_EPOCH};
 use std::io::{BufRead, Write};
 
+use bsvfs::{Metadata, Permissions};
 use cas_core::{err, Error, ObjectId, ObjectType, Result};
 
-use crate::Permissions;
-
 
 pub trait Serialize {
     fn serialize<W: Write>(&self, out: &mut W) -> Result<()>;
@@ -51,9 +50,10 @@ pub struct TreeItem {
 }
 
 impl TreeItem {
-    pub fn from_metadata(name: String, metadata: &std::fs::Metadata, oid: ObjectId) -> Result<Self> {
+    // pub fn from_metadata(name: String, metadata: &std::fs::Metadata, oid: ObjectId) -> Result<Self> {
+    pub fn from_metadata<M: Metadata>(name: String, metadata: &M, oid: ObjectId) -> Result<Self> {
         let otype = otype_from_metadata(metadata)?;
-        let permissions = Permissions::from_metadata(metadata)?;
+        let permissions = metadata.permissions();
 
         Ok(Self {
             name: name,
@@ -134,7 +134,7 @@ impl Serialize for [TreeItem] {
 }
 
 
-pub fn otype_from_metadata(metadata: &std::fs::Metadata) -> Result<ObjectType> {
+pub fn otype_from_metadata<M: Metadata>(metadata: &M) -> Result<ObjectType> {
     let file_type = metadata.file_type();
 
     if file_type.is_file() {
@@ -193,7 +193,7 @@ mod tests {
             size: 42,
             created: UNIX_EPOCH + Duration::from_secs(1234),
             modified: UNIX_EPOCH + Duration::from_secs(5678),
-            permissions: Permissions { read: true, write: false, execute: true },
+            permissions: Permissions::new(true, false, true),
             oid: ObjectId::from_str("0123456789abcdef").unwrap(),
         };
         let expected = "0123456789abcdef\ttest\t42\tr-x\t1234000\t5678000\tTest $¢ह€한/\n".as_bytes();
@@ -216,7 +216,7 @@ mod tests {
             size: 42,
             created: UNIX_EPOCH + Duration::from_secs(1234),
             modified: UNIX_EPOCH + Duration::from_secs(5678),
-            permissions: Permissions { read: true, write: false, execute: true },
+            permissions: Permissions::new(true, false, true),
             oid: ObjectId::from_str("0123456789abcdef").unwrap(),
         };
 

libbsv/src/tree_walker.rs

@@ -15,14 +15,15 @@
 
 
 use std::iter::Peekable;
-use std::fs::{DirEntry, Metadata, ReadDir, read_dir};
+// use std::fs::{DirEntry, Metadata, ReadDir, read_dir};
 use std::vec::IntoIter;
 
-use camino::{Utf8Path, Utf8PathBuf};
+use camino::{Utf8Path};
 
-use cas_core::{err, Error, ObjectId, Result};
+use bsvfs::{DirEntry, FileSystem};
+use cas_core::{ObjectId, Result};
 
-use crate::{PathPair, Repository, TreeItem};
+use crate::{TreeItem};
 
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -31,7 +32,7 @@ pub enum Action {
     Update,
     Remove,
     Skip,
-    Ignore,
+    // Ignore,
 }
 
 pub struct TreeWalker {
@@ -41,18 +42,14 @@ pub struct TreeWalker {
 
 
 impl TreeWalker {
-    pub fn new<P: AsRef<Utf8Path>>(path: P, prev_tree: Vec<TreeItem>) -> Result<Self> {
-        let dir_entries = read_dir(path.as_ref().to_path_buf())?
+    pub fn new<Fs: FileSystem, P: AsRef<Utf8Path>>(fs: Fs, path: P, prev_tree: Vec<TreeItem>) -> Result<Self> {
+        let dir_entries = fs.read_dir(path.as_ref().to_path_buf())?
             .map(|res| res.map_err(|err| err.into()))
             .collect::<Result<Vec<_>>>()?;
 
         let mut dir_items: Vec<_> = dir_entries.into_iter()
             .map(|dir_entry| {
-                let file_name = dir_entry
-                    .file_name()
-                    .into_string()
-                    // .or_else(|os_string| err!("non-unicode file name '{}'", os_string.to_string_lossy()))?;
-                    .or_else(|os_string| Err(Error::NonUnicodeFileName(os_string.to_string_lossy().into())))?;
+                let file_name = dir_entry.file_name()?;
             let metadata = dir_entry.metadata()?;
                 Ok(TreeItem::from_metadata(
                         file_name,
@@ -117,11 +114,13 @@ impl Iterator for TreeWalker {
 
 #[cfg(test)]
 mod tests {
+    use bsvfs::SysFileSystem;
+
     use super::*;
 
     #[test]
     fn test_tree_walker() {
-        for item in TreeWalker::new("/home/draklaw/tmp", vec![]).unwrap() {
+        for item in TreeWalker::new(SysFileSystem::new(), "/home/draklaw/tmp", vec![]).unwrap() {
             match item {
                 Ok((action, tree_item)) => println!("{:?} {:?}", action, tree_item.name),
                 Err(err) => println!("error while iterating directory: {}", err),