quilt-rs 0.4.2

Rust library for accessing Quilt data packages.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97

//! 
//! UPath is a path abstraction that can be used to represent a path in a
//! local filesystem or remote object_store.
//! It is used to represent the path to a file or directory in a local domain,
//! or the path to an object or prefix in a remote object store.
//! It will eventually also support web and document stores.
//! 

use std::path::PathBuf;
use object_store::path::Path;
use std::io;
use multihash::Multihash;
use serde::{Deserialize, Serialize};
use aptos_openapi_link::impl_poem_type;
impl_poem_type!(UPath, "object", ());

use super::client::Client;
use super::uri::UriParser;

#[derive(Clone, Debug, Deserialize, Serialize)]
// FIXME: This should be a union, not a struct
pub struct UPath {
    pub uri: String,
    pub file_path: Option<PathBuf>,
    #[serde(skip)]
    pub object_path: Option<Path>,
    pub object_bucket: Option<String>,
}

impl UPath {
    pub fn new(uri_string: String) -> Self {
        let uri = UriParser::try_from(&uri_string).unwrap();
        let file_path = if uri.scheme == "file" {
            Some(PathBuf::from(uri.path.clone()))
        } else {
            None
        };
        let object_path = if uri.scheme == "s3" {
            Some(Path::from(uri.path.clone()))
        } else {
            None
        };
        let object_bucket = if uri.scheme == "s3" {
            Some(uri.host)
        } else {
            None
        };
        UPath {
            uri: uri_string,
            file_path,
            object_path,
            object_bucket,
        }
    }

    pub fn to_string(&self) -> String {
        format!("UPath({})", self.uri)
    }

    pub async fn read_bytes(&self, _client: Client) -> io::Result<Vec<u8>> { unimplemented!() }
    pub async fn write_bytes(&self, _client: Client, _input: Vec<u8>) -> io::Result<Vec<u8>> { unimplemented!() }

    pub async fn parent(&self) -> Option<UPath> {
        // TODO: Implement parent method
        unimplemented!()
    }

    pub async fn hash(&self, _algorithm: String) -> Multihash<128> {
        // TODO: Implement hash method
        unimplemented!()
    }

    pub async fn is_folder(&self) -> bool {
        // TODO: Implement is_folder method
        unimplemented!()
    }


}

#[cfg(test)]
mod tests {
    use super::*;
    #[test]
    fn test_new_local() {
        let local_uri = utils::local_uri_parquet();
        let upath = UPath::new(local_uri.clone());
        println!("upath: {:?}", upath);
        assert_eq!(upath.uri, local_uri);
        let upath_string = upath.to_string();
        assert_eq!(upath_string, format!("UPath({})", local_uri));
        assert_eq!(upath.object_bucket, None);
        assert_eq!(upath.object_path, None);
        let fpath = upath.file_path.unwrap();
        assert_eq!(local_uri, format!("file://{}", fpath.to_string_lossy()));
    }
}