commot 0.1.0

A better alternative to the cat command.
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
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152

use std::io::{BufReader, Read};
use std::fs::{File, metadata};
use std::path::PathBuf;
use chrono::{DateTime, Utc};

use crate::errors::CommotError;

/// File Reader

#[derive(Clone, Debug)]
pub struct Reader {
    pub path: PathBuf,
}

/// `FileSizeType`
/// This enum has all the size types which are storing the size inside them.
#[derive(Clone, Debug)]
pub enum FileSizeType {
    Bytes(u64),
    KiloBytes(u64),
    MegaBytes(u64),
    GigaBytes(u64)
}


#[derive(Clone, Debug)]
pub struct FileMetadata {
    pub size: FileSize,
    pub created: DateTime<Utc>,
    pub modified: DateTime<Utc>,
    pub accessed: DateTime<Utc>,
}
impl FileMetadata {
    pub fn new(
        size: FileSize,
        created: DateTime<Utc>,
        modified: DateTime<Utc>,
        accessed: DateTime<Utc>


    ) -> Self {
        Self {
            size,
            created,
            modified,
            accessed
        }
    }
}

impl FileSizeType {
    pub fn new(bytes: u64) -> Self {
        let kb = bytes / 1000;
        let mb = kb / 1000;
        let gb = mb / 1000;
        if bytes < 1000 {
            FileSizeType::Bytes(bytes)
        } else if bytes >= 1000 {
            FileSizeType::KiloBytes(kb)
        } else if kb >= 1000 {
            FileSizeType::MegaBytes(mb)
        } else {
            FileSizeType::GigaBytes(gb)
        }
    }
    pub fn to_string(&self) -> String {
        match self {
            Self::Bytes(v) => format!("{} byte(s)", v),
            Self::KiloBytes(v) => format!("{} kilobyte(s)", v),
            Self::MegaBytes(v) => format!("{} megabyte(s)", v),
            Self::GigaBytes(v) => format!("{} gigabyte(s)", v)
        }

    }

    pub fn into_inner(&self) -> u64 {
        match &self {
            FileSizeType::Bytes(v) => v.to_owned(),
            FileSizeType::KiloBytes(v) => v.to_owned(),
            FileSizeType::MegaBytes(v) => v.to_owned(),
            FileSizeType::GigaBytes(v) => v.to_owned(),
        }
    }

    
    
}
#[derive(Clone, Debug)]
pub struct FileSize(FileSizeType);

impl FileSize {
    pub fn new(size: FileSizeType) -> Self {
        Self(size)
    }

   pub fn into_inner(&self) -> FileSizeType {
       self.0.clone()
   }
}

pub struct FileData(String);
impl FileData {
    pub fn new(data: String) -> Self {
        Self(data)
    }

    pub fn into_inner(&self) -> String {
        self.0.to_owned()
    }
}
/// Implementing methods on the reader like "read", "file_size", etc.
impl Reader {
    pub fn new(path: String) -> Self{ 
        Self {path: path.into()}
    }
    pub fn read(&self) -> Result<FileData, CommotError> {
        let file = File::open(&self.path)?;
        let mut reader = BufReader::new(file);
        let mut buffer = String::new();
        reader.read_to_string(&mut buffer)?;
        Ok(FileData::new(buffer))
    }

    
    pub fn size(&self) -> Result<FileSize, CommotError> {
        let file_metadata = metadata(&self.path)?;
        let file_size = FileSize::new(FileSizeType::new(file_metadata.len()));
        Ok(file_size)
        
    }


    pub fn created(&self) -> Result<DateTime<Utc>, CommotError> {
        let file_metadata = metadata(&self.path)?;
        Ok(file_metadata.created()?.into()) 
    }

    pub fn accessed(&self) -> Result<DateTime<Utc>, CommotError> {
        let file_metadata = metadata(&self.path)?;
        Ok(file_metadata.accessed()?.into()) 
    }
    pub fn modified(&self) -> Result<DateTime<Utc>, CommotError> {
        let file_metadata = metadata(&self.path)?;
        Ok(file_metadata.modified()?.into()) 
    }

    pub fn metadata(&self) -> Result<FileMetadata, CommotError> {
        Ok(
            FileMetadata::new(self.size()?, self.created()?, self.modified()?, self.accessed()?)
        )
    }
}