lakestream 0.0.3

Portable file-utility for object-stores
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
98
99
100
101
102
103
104

use regex::Regex;

pub struct ParsedUri {
    pub scheme: Option<String>,
    pub bucket: Option<String>,
    pub path: Option<String>,
}

impl ParsedUri {
    pub fn from_uri(uri: &str, append_slash: bool) -> ParsedUri {
        if uri.is_empty() {
            return ParsedUri {
                scheme: None,
                bucket: None,
                path: None,
            };
        }

        let re = Regex::new(r"^(?P<scheme>[a-z0-9]+)://").unwrap();
        let scheme_match = re.captures(uri);

        scheme_match.map_or_else(
            || {
                // uri has no scheme, assume LocalFsBucket
                let (bucket, path) = parse_uri_path(None, uri, append_slash);
                ParsedUri {
                    scheme: None,
                    bucket,
                    path,
                }
            },
            |scheme_captures| {
                let scheme = scheme_captures.name("scheme").unwrap().as_str();
                let uri_without_scheme = re.replace(uri, "").to_string();
                if uri_without_scheme.is_empty() {
                    ParsedUri {
                        scheme: Some(scheme.to_string()),
                        bucket: None,
                        path: None,
                    }
                } else {
                    let (bucket, path) = parse_uri_path(
                        Some(scheme),
                        &uri_without_scheme,
                        append_slash,
                    );
                    ParsedUri {
                        scheme: Some(scheme.to_string()),
                        bucket,
                        path,
                    }
                }
            },
        )
    }
}

fn parse_uri_path(
    scheme: Option<&str>,
    uri_path: &str,
    append_slash: bool,
) -> (Option<String>, Option<String>) {
    let cleaned_uri = uri_path.trim_end_matches('.');

    if cleaned_uri.is_empty() {
        return (Some(".".to_string()), None);
    }

    let is_absolute = cleaned_uri.starts_with('/');
    let mut parts = cleaned_uri.splitn(2, '/');
    let bucket = parts.next().map(|s| s.to_string());

    let path = parts.next().filter(|s| !s.is_empty()).map(|s| {
        let cleaned_path = s.replace("./", "");
        if cleaned_path.ends_with('/') {
            if append_slash {
                cleaned_path
            } else {
                cleaned_path.trim_end_matches('/').to_string()
            }
        } else if append_slash {
            format!("{}/", cleaned_path)
        } else {
            cleaned_path
        }
    });

    // If there is no path, treat the input as a path instead of a bucket
    // bucket is currenth path on LocalFs
    if scheme.is_none() && path.is_none() && bucket.is_some() {
        return (Some(".".to_string()), bucket);
    }

    if let Some(bucket) = bucket {
        let formatted_bucket = if is_absolute {
            format!("/{}", bucket)
        } else {
            bucket
        };
        return (Some(formatted_bucket), path);
    }

    (Some(".".to_string()), None)
}