mindflow 0.1.1

A command line client for Mindflow
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
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136

// Contains the implementation of the PathResolver struct and the ResolvedFilePath struct.
// ResolvedFilePath:
//    - Implements the Resolved trait.
// PathResolver:
//    - Implements the Resolver trait.

use std::{fs};
use std::path::Path;
use std::str::from_utf8;

use sha2::{Digest, Sha256};

use crate::resolve_handling::resolve::Resolved;
use crate::utils::{git::{get_git_files, is_within_git_repo}, reference::Reference};

pub struct ResolvedFilePath {
    pub path: String,
}

// ResolvedFilePath implements the Resolved trait create a reference and extract other data about the file. 
impl ResolvedFilePath {
    pub fn create_reference(&self) -> Option<Reference> {
        let text_bytes = match fs::read(self.path.clone()) {
            Ok(bytes) => bytes,
            Err(e) => {
                log::debug!("Could not read file: {}. error {:?}", self.path, e);
                return None
            }
        };
        match from_utf8(&text_bytes) {
            Ok(text) => {
                let mut hasher = Sha256::new();
                hasher.update(&text_bytes);
                let file_hash = format!("{:x}", hasher.finalize());
                Some(Reference::new("file".to_string(), file_hash, text.to_string(), self.path.clone()))
            },
            Err(_e) => {
                log::debug!("Could not convert bytes to utf8: {}", self.path);
                None
            }
        }
    }

    pub fn get_path(&self) -> &str {
        &self.path
    }

    pub fn size_bytes(&self) -> Option<u64> {
        match fs::metadata(self.path.clone()) {
            Ok(meta_data) => Some(meta_data.len()),
            Err(e) => {
                log::debug!("Could not read file: {}. Error: {:?}", self.path, e);
                None
            }
        }
    }

    pub fn text_hash(&self) -> Option<String> {
        let text_bytes = match fs::read(self.path.clone()) {
            Ok(bytes) => bytes,
            Err(e) => {
                log::debug!("Could not read file: {}. Error: {:?}", self.path, e);
                return None
            }
        };
        
        // Create a Sha256 hasher
        let mut hasher = Sha256::new();
        hasher.update(text_bytes);

        // Create and return the sha256 hash of the file
        Some(format!("{:x}", hasher.finalize()))
    }
}

// ResolvedFilePath implements the Resolved trait to resolve references in the PathResolved type.
pub struct PathResolver {}

impl PathResolver {
    pub fn extract_files(&self, path: &Path) -> Vec<String> {
        // If the path is a file, return it as the only item in a vector
        if path.is_file() {
            return vec![path.to_string_lossy().to_string()];
        }

        // Check if the path is within a git repository
        if is_within_git_repo(path) {
            return get_git_files(path);
        } 

        // Read all the files and directories in the path, and recursively extract files from directories
        let mut file_paths = Vec::new();
        match fs::read_dir(path) {
            Ok(entries) => {
                for entry in entries {
                    match entry {
                        Ok(entry) => {
                            let path = entry.path();
                            match path.is_dir() {
                                true => {
                                    file_paths.extend(self.extract_files(&path));
                                },
                                false => {
                                    file_paths.push(path.to_string_lossy().to_string());
                                }
                            }
                        },
                        // If the directory could not be read, log the error
                        Err(e) => {
                            log::debug!("Could not read directory: {}. Error: {:?}", path.to_string_lossy(), e);
                        }
                    }
                }
                file_paths
            },
            // If the directory could not be read, log the error
            Err(e) => {
                log::debug!("Could not read directory: {}. Error: {:?}", path.to_string_lossy(), e);
                file_paths
            }
        }
    }

    pub fn should_resolve(&self, path_string: &str) -> bool {
        let path = Path::new(path_string);
        path.is_dir() || path.is_file()
    }

    pub async fn resolve(&self, path: &str) -> Vec<Resolved> {
        // Create a ResolvedPath for each file path and return it as a vec
        self.extract_files(Path::new(path))
            .into_iter()
            .map(|file_path| Resolved::ResolvedFilePath(ResolvedFilePath { path: file_path }))
            .collect()
    }
}