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
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
|
//! Wrapper types for the values returned from `File`s.
//!
//! The methods of `File` that return information about the entry on the
//! filesystem -- size, modification date, block count, or Git status -- used
//! to just return these as formatted strings, but this became inflexible once
//! customisable output styles landed.
//!
//! Instead, they will return a wrapper type from this module, which tags the
//! type with what field it is while containing the actual raw value.
//!
//! The `output::details` module, among others, uses these types to render and
//! display the information as formatted strings.
// C-style `blkcnt_t` types don’t follow Rust’s rules!
#![allow(non_camel_case_types)]
/// The type of a file’s block count.
pub type blkcnt_t = u64;
/// The type of a file’s group ID.
pub type gid_t = u32;
/// The type of a file’s inode.
pub type ino_t = u64;
/// The type of a file’s number of links.
pub type nlink_t = u64;
/// The type of a file’s timestamp (creation, modification, access, etc).
pub type time_t = i64;
/// The type of a file’s user ID.
pub type uid_t = u32;
/// The file’s base type, which gets displayed in the very first column of the
/// details output.
///
/// This type is set entirely by the filesystem, rather than relying on a
/// file’s contents. So “link” is a type, but “image” is just a type of
/// regular file. (See the `filetype` module for those checks.)
///
/// Its ordering is used when sorting by type.
#[derive(PartialEq, Eq, PartialOrd, Ord)]
pub enum Type {
Directory, File, Link, Pipe, Socket, CharDevice, BlockDevice, Special,
}
impl Type {
pub fn is_regular_file(&self) -> bool {
matches!(*self, Type::File)
}
}
/// The file’s Unix permission bitfield, with one entry per bit.
pub struct Permissions {
pub user_read: bool,
pub user_write: bool,
pub user_execute: bool,
pub group_read: bool,
pub group_write: bool,
pub group_execute: bool,
pub other_read: bool,
pub other_write: bool,
pub other_execute: bool,
pub sticky: bool,
pub setgid: bool,
pub setuid: bool,
}
/// The three pieces of information that are displayed as a single column in
/// the details view. These values are fused together to make the output a
/// little more compressed.
pub struct PermissionsPlus {
pub file_type: Type,
pub permissions: Permissions,
pub xattrs: bool,
}
/// The permissions encoded as octal values
pub struct OctalPermissions {
pub permissions: Permissions,
}
/// A file’s number of hard links on the filesystem.
///
/// Under Unix, a file can exist on the filesystem only once but appear in
/// multiple directories. However, it’s rare (but occasionally useful!) for a
/// regular file to have a link count greater than 1, so we highlight the
/// block count specifically for this case.
pub struct Links {
/// The actual link count.
pub count: nlink_t,
/// Whether this file is a regular file with more than one hard link.
pub multiple: bool,
}
/// A file’s inode. Every directory entry on a Unix filesystem has an inode,
/// including directories and links, so this is applicable to everything exa
/// can deal with.
pub struct Inode(pub ino_t);
/// The number of blocks that a file takes up on the filesystem, if any.
pub enum Blocks {
/// This file has the given number of blocks.
Some(blkcnt_t),
/// This file isn’t of a type that can take up blocks.
None,
}
/// The ID of the user that owns a file. This will only ever be a number;
/// looking up the username is done in the `display` module.
pub struct User(pub uid_t);
/// The ID of the group that a file belongs to.
pub struct Group(pub gid_t);
/// A file’s size, in bytes. This is usually formatted by the `number_prefix`
/// crate into something human-readable.
pub enum Size {
/// This file has a defined size.
Some(u64),
/// This file has no size, or has a size but we aren’t interested in it.
///
/// Under Unix, directory entries that aren’t regular files will still
/// have a file size. For example, a directory will just contain a list of
/// its files as its “contents” and will be specially flagged as being a
/// directory, rather than a file. However, seeing the “file size” of this
/// data is rarely useful -- I can’t think of a time when I’ve seen it and
/// learnt something. So we discard it and just output “-” instead.
///
/// See this answer for more: http://unix.stackexchange.com/a/68266
None,
/// This file is a block or character device, so instead of a size, print
/// out the file’s major and minor device IDs.
///
/// This is what ls does as well. Without it, the devices will just have
/// file sizes of zero.
DeviceIDs(DeviceIDs),
}
/// The major and minor device IDs that gets displayed for device files.
///
/// You can see what these device numbers mean:
/// - http://www.lanana.org/docs/device-list/
/// - http://www.lanana.org/docs/device-list/devices-2.6+.txt
pub struct DeviceIDs {
pub major: u8,
pub minor: u8,
}
/// One of a file’s timestamps (created, accessed, or modified).
#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord)]
pub struct Time {
pub seconds: time_t,
pub nanoseconds: time_t,
}
/// A file’s status in a Git repository. Whether a file is in a repository or
/// not is handled by the Git module, rather than having a “null” variant in
/// this enum.
#[derive(PartialEq)]
pub enum GitStatus {
/// This file hasn’t changed since the last commit.
NotModified,
/// This file didn’t exist for the last commit, and is not specified in
/// the ignored files list.
New,
/// A file that’s been modified since the last commit.
Modified,
/// A deleted file. This can’t ever be shown, but it’s here anyway!
Deleted,
/// A file that Git has tracked a rename for.
Renamed,
/// A file that’s had its type (such as the file permissions) changed.
TypeChange,
/// A file that’s ignored (that matches a line in .gitignore)
Ignored,
/// A file that's updated but unmerged.
Conflicted,
}
/// A file’s complete Git status. It’s possible to make changes to a file, add
/// it to the staging area, then make *more* changes, so we need to list each
/// file’s status for both of these.
pub struct Git {
pub staged: GitStatus,
pub unstaged: GitStatus,
}
use std::default::Default;
impl Default for Git {
/// Create a Git status for a file with nothing done to it.
fn default() -> Git {
Git { staged: GitStatus::NotModified, unstaged: GitStatus::NotModified }
}
}
|