jfsm 0.1.5

A command-line tool to read file system metadata then return it in JSON format (output and errors).
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
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

use serde::{Deserialize, Serialize};
use crate::raw::RawMetadata;
use std::path::Path;
use std::env;
// false positive warning for unused imports
#[allow(unused_imports)]
use pathdiff::diff_paths;

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct FpDirMetadata {
    pub dirn: String,
    pub basen: String,
    pub relp: String,
    pub reldirp: String,
    pub ext: String,
    pub fnnoext: String,
    pub shortp: String,
    pub filet: String,
    pub sizeh: String,
}

impl FpDirMetadata {
    pub fn from_raw(raw: &RawMetadata) -> Self {
        // Use the canonicalized pathname to ensure we have an absolute path
        let path = Path::new(&raw.pathname);
        
        // Get current working directory
        let current_dir = env::current_dir().unwrap_or_else(|_| Path::new(".").to_path_buf());
        
        // Directory name (absolute path without filename)
        let dir_name = path.parent()
            .map(|p| p.to_string_lossy().to_string())
            .unwrap_or_else(|| "/".to_string());
        
        // Base name (file name with extension)
        let base_name = path.file_name()
            .map(|n| n.to_string_lossy().to_string())
            .unwrap_or_default();
        
        // Relative path from current directory
        let rel_path = path.strip_prefix(&current_dir)
            .map(|p| p.to_string_lossy().to_string())
            .unwrap_or_else(|_| {
                // If strip_prefix fails, we need to compute the relative path manually
                // This happens when the path is not a subpath of current_dir
                pathdiff::diff_paths(&path, &current_dir)
                    .map(|p| p.to_string_lossy().to_string())
                    .unwrap_or_else(|| path.to_string_lossy().to_string())
            });
        
        // Relative folder path from current directory
        let rel_dir_path = path.parent()
            .and_then(|p| p.strip_prefix(&current_dir).ok())
            .map(|p| p.to_string_lossy().to_string())
            .unwrap_or_else(|| {
                path.parent()
                    .and_then(|p| pathdiff::diff_paths(p, &current_dir))
                    .map(|p| p.to_string_lossy().to_string())
                    .unwrap_or_else(|| {
                        path.parent()
                            .map(|p| p.to_string_lossy().to_string())
                            .unwrap_or_default()
                    })
            });
        
        // File extension
        let extension = path.extension()
            .map(|e| e.to_string_lossy().to_string())
            .unwrap_or_default();
        
        // File name without extension
        let file_name_no_ext = path.file_stem()
            .map(|n| n.to_string_lossy().to_string())
            .unwrap_or(base_name.clone());
        
        // Short path (parent_directory/filename_with_extension)
        let short_path = if let Some(parent) = path.parent() {
            if let Some(parent_name) = parent.file_name() {
                format!("{}/{}", parent_name.to_string_lossy(), base_name)
            } else {
                base_name.clone()
            }
        } else {
            base_name.clone()
        };
        
        // File type in human-readable format
        let file_type = match raw.ftvalue.as_str() {
            "S_IFDIR" => "directory".to_string(),
            "S_IFREG" => "regular file".to_string(),
            "S_IFLNK" => "symlink".to_string(),
            "S_IFBLK" => "block device".to_string(),
            "S_IFCHR" => "character device".to_string(),
            "S_IFIFO" => "FIFO/pipe".to_string(),
            "S_IFSOCK" => "socket".to_string(),
            _ => "unknown".to_string(),
        };
        
        // Human-readable size
        let size_human = format_size(raw.size);
        
        FpDirMetadata {
            dirn: dir_name,
            basen: base_name,
            relp: rel_path,
            reldirp: rel_dir_path,
            ext: extension,
            fnnoext: file_name_no_ext,
            shortp: short_path,
            filet: file_type,
            sizeh: size_human,
        }
    }
}

// Helper function to format size in human-readable format
fn format_size(size: u64) -> String {
    const UNITS: &[&str] = &["B", "KB", "MB", "GB", "TB"];
    let mut size = size as f64;
    let mut unit_index = 0;
    
    while size >= 1024.0 && unit_index < UNITS.len() - 1 {
        size /= 1024.0;
        unit_index += 1;
    }
    
    if unit_index == 0 {
        format!("{} {}", size as u64, UNITS[unit_index])
    } else {
        format!("{:.1} {}", size, UNITS[unit_index])
    }
}