From 9cfeb6500e8fca7d6e03436a6ab3b5901c4fd6f5 Mon Sep 17 00:00:00 2001
From: Uggla <uggla@free.fr>
Date: Fri, 8 Nov 2024 22:21:58 +0100
Subject: [PATCH 1/2] Add command line optional argument ftime

- This argument can take 3 value atime (access), btime(birth),
  mtime(modification).
- This argument will be used to change the file time displayed
  accordingly.
---
 doc/lsd.md         |  17 +--
 src/app.rs         |  12 +++
 src/config_file.rs |   3 +
 src/flags.rs       |   4 +
 src/flags/ftime.rs | 261 +++++++++++++++++++++++++++++++++++++++++++++
 src/meta/date.rs   |   2 +-
 6 files changed, 291 insertions(+), 8 deletions(-)
 create mode 100644 src/flags/ftime.rs

diff --git a/doc/lsd.md b/doc/lsd.md
index 78a120465..f467321f7 100644
--- a/doc/lsd.md
+++ b/doc/lsd.md
@@ -96,7 +96,7 @@ lsd is a ls command with a lot of pretty colours and some other stuff to enrich
 : Specify the blocks that will be displayed and in what order [possible values: permission, user, group, size, date, name, inode, git]
 
 `--color <color>...`
-: When to use terminal colours [default: auto]  [possible values: always, auto, never]
+: When to use terminal colours [default: auto] [possible values: always, auto, never]
 
 `--date <date>...`
 : How to display date [possible values: date, locale, relative, +date-time-format] [default: date]
@@ -104,29 +104,32 @@ lsd is a ls command with a lot of pretty colours and some other stuff to enrich
 `--depth <num>...`
 : Stop recursing into directories after reaching specified depth
 
+`--ftime <time>...`
+: Which file timestamp to display [possible values: mtime (modification time), btime (birth time), atime (access time)] [default: mtime]
+
 `--group-dirs <group-dirs>...`
-: Sort the directories then the files [default: none]  [possible values: none, first, last]
+: Sort the directories then the files [default: none] [possible values: none, first, last]
 
 `--group-directories-first`
 : Groups the directories at the top before the files. Same as `--group-dirs=first`
 
 `--hyperlink <hyperlink>...`
-: Attach hyperlink to filenames [default: never]  [possible values: always, auto, never]
+: Attach hyperlink to filenames [default: never] [possible values: always, auto, never]
 
 `--icon <icon>...`
-: When to print the icons [default: auto]  [possible values: always, auto, never]
+: When to print the icons [default: auto] [possible values: always, auto, never]
 
 `--icon-theme <icon-theme>...`
-: Whether to use fancy or unicode icons [default: fancy]  [possible values: fancy, unicode]
+: Whether to use fancy or unicode icons [default: fancy] [possible values: fancy, unicode]
 
 `-I, --ignore-glob <pattern>...`
 : Do not display files/directories with names matching the glob pattern(s). More than one can be specified by repeating the argument [default: ]
 
 `--permission <permission>...`
-: How to display permissions [default: rwx for linux, attributes for windows]  [possible values: rwx, octal, attributes, disable]
+: How to display permissions [default: rwx for linux, attributes for windows] [possible values: rwx, octal, attributes, disable]
 
 `--size <size>...`
-: How to display size [default: default]  [possible values: default, short, bytes]
+: How to display size [default: default] [possible values: default, short, bytes]
 
 `--sort <WORD>...`
 : Sort by WORD instead of name [possible values: size, time, version, extension, git]
diff --git a/src/app.rs b/src/app.rs
index fa329592e..f62b48d3a 100644
--- a/src/app.rs
+++ b/src/app.rs
@@ -193,6 +193,10 @@ pub struct Cli {
     #[arg(short = 'N', long)]
     pub literal: bool,
 
+    /// Displayed file time [default: mtime] [possible values: mtime (modification time), btime (birth time), atime (access time)]
+    #[arg(long, value_parser = validate_ftime_argument)]
+    pub ftime: Option<String>,
+
     /// Print help information
     #[arg(long, action = ArgAction::Help)]
     help: (),
@@ -208,6 +212,14 @@ fn validate_date_argument(arg: &str) -> Result<String, String> {
     }
 }
 
+fn validate_ftime_argument(arg: &str) -> Result<String, String> {
+    if arg == "mtime" || arg == "atime" || arg == "btime" {
+        Result::Ok(arg.to_owned())
+    } else {
+        Result::Err("possible values: mtime, btime, atime".to_owned())
+    }
+}
+
 pub fn validate_time_format(formatter: &str) -> Result<String, String> {
     let mut chars = formatter.chars();
     loop {
diff --git a/src/config_file.rs b/src/config_file.rs
index e91b5884c..e4974fb7c 100644
--- a/src/config_file.rs
+++ b/src/config_file.rs
@@ -44,6 +44,7 @@ pub struct Config {
     pub header: Option<bool>,
     pub literal: Option<bool>,
     pub truncate_owner: Option<TruncateOwner>,
+    pub ftime: Option<String>,
 }
 
 #[derive(Eq, PartialEq, Debug, Deserialize)]
@@ -129,6 +130,7 @@ impl Config {
             header: None,
             literal: None,
             truncate_owner: None,
+            ftime: None,
         }
     }
 
@@ -428,6 +430,7 @@ mod tests {
                     after: None,
                     marker: Some("".to_string()),
                 }),
+                ftime: None,
             },
             c
         );
diff --git a/src/flags.rs b/src/flags.rs
index 52e7a49a0..68c449c3d 100644
--- a/src/flags.rs
+++ b/src/flags.rs
@@ -3,6 +3,7 @@ pub mod color;
 pub mod date;
 pub mod dereference;
 pub mod display;
+pub mod ftime;
 pub mod header;
 pub mod hyperlink;
 pub mod icons;
@@ -25,6 +26,7 @@ pub use color::{ColorOption, ThemeOption};
 pub use date::DateFlag;
 pub use dereference::Dereference;
 pub use display::Display;
+pub use ftime::FileTimeFlag;
 pub use header::Header;
 pub use hyperlink::HyperlinkOption;
 pub use icons::IconOption;
@@ -77,6 +79,7 @@ pub struct Flags {
     pub header: Header,
     pub literal: Literal,
     pub truncate_owner: TruncateOwner,
+    pub ftime: FileTimeFlag,
 }
 
 impl Flags {
@@ -108,6 +111,7 @@ impl Flags {
             header: Header::configure_from(cli, config),
             literal: Literal::configure_from(cli, config),
             truncate_owner: TruncateOwner::configure_from(cli, config),
+            ftime: FileTimeFlag::configure_from(cli, config),
         })
     }
 }
diff --git a/src/flags/ftime.rs b/src/flags/ftime.rs
new file mode 100644
index 000000000..6494783f7
--- /dev/null
+++ b/src/flags/ftime.rs
@@ -0,0 +1,261 @@
+//! This module defines the [FileTimeFlag]. To set it up from [Cli], a [Config] and its
+//! [Default] value, use its [configure_from](Configurable::configure_from) method.
+
+use super::Configurable;
+
+use crate::app::Cli;
+use crate::config_file::Config;
+use crate::print_error;
+
+/// The flag showing which kind of time stamps to display.
+#[derive(Clone, Debug, PartialEq, Eq, Default)]
+pub enum FileTimeFlag {
+    #[default]
+    Modification,
+    Birth,
+    Access,
+}
+
+impl FileTimeFlag {
+    /// Get a value from a str.
+    fn from_str<S: AsRef<str>>(value: S) -> Option<Self> {
+        let value = value.as_ref();
+        match value {
+            "mtime" => Some(Self::Modification),
+            "btime" => Some(Self::Birth),
+            "atime" => Some(Self::Access),
+            _ => {
+                print_error!("Not a valid ftime value: {}.", value);
+                None
+            }
+        }
+    }
+}
+
+impl Configurable<Self> for FileTimeFlag {
+    /// Get a potential `FileTimeFlag` variant from [Cli].
+    ///
+    /// If the "classic" argument is passed, then this returns the [FileTimeFlag::ModificationTime] variant in a
+    /// [Some]. Otherwise if the argument is passed, this returns the variant corresponding to its
+    /// parameter in a [Some]. Otherwise this returns [None].
+    fn from_cli(cli: &Cli) -> Option<Self> {
+        if cli.classic {
+            Some(Self::Modification)
+        } else {
+            cli.ftime.as_deref().and_then(Self::from_str)
+        }
+    }
+
+    /// Get a potential `FileTimeFlag` variant from a [Config].
+    ///
+    /// If the `Config::classic` is `true` then this returns the Some(FileTimeFlag::Date),
+    /// Otherwise if the `Config::date` has value and is one of "date", "locale" or "relative",
+    /// this returns its corresponding variant in a [Some].
+    /// Otherwise this returns [None].
+    fn from_config(config: &Config) -> Option<Self> {
+        if config.classic == Some(true) {
+            Some(Self::Modification)
+        } else {
+            config.ftime.as_ref().and_then(Self::from_str)
+        }
+    }
+
+    /// Get a potential `FileTimeFlag` variant from the environment.
+    fn from_environment() -> Option<Self> {
+        if let Ok(value) = std::env::var("LSD_FILE_TIME") {
+            match value.as_str() {
+                "atime" => Some(Self::Access),
+                "btime" => Some(Self::Birth),
+                "mtime" => Some(Self::Modification),
+                _ => {
+                    print_error!("Not a valid date value: {}.", value);
+                    None
+                }
+            }
+        } else {
+            None
+        }
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use clap::Parser;
+
+    use super::FileTimeFlag;
+
+    use crate::app::Cli;
+    use crate::config_file::Config;
+    use crate::flags::Configurable;
+
+    #[test]
+    fn test_from_cli_none() {
+        let argv = ["lsd"];
+        let cli = Cli::try_parse_from(argv).unwrap();
+        assert_eq!(None, FileTimeFlag::from_cli(&cli));
+    }
+
+    #[test]
+    fn test_from_cli_mtime() {
+        let argv = ["lsd", "--ftime", "mtime"];
+        let cli = Cli::try_parse_from(argv).unwrap();
+        assert_eq!(
+            Some(FileTimeFlag::Modification),
+            FileTimeFlag::from_cli(&cli)
+        );
+    }
+
+    #[test]
+    fn test_from_cli_atime() {
+        let argv = ["lsd", "--ftime", "atime"];
+        let cli = Cli::try_parse_from(argv).unwrap();
+        assert_eq!(Some(FileTimeFlag::Access), FileTimeFlag::from_cli(&cli));
+    }
+
+    #[test]
+    fn test_from_cli_btime() {
+        let argv = ["lsd", "--ftime", "btime"];
+        let cli = Cli::try_parse_from(argv).unwrap();
+        assert_eq!(Some(FileTimeFlag::Birth), FileTimeFlag::from_cli(&cli));
+    }
+
+    #[test]
+    #[should_panic = "possible values: mtime, btime, atime"]
+    fn test_from_cli_invalid() {
+        let argv = ["lsd", "--ftime", "foo"];
+        let cli = Cli::try_parse_from(argv).unwrap();
+        dbg!(&cli);
+        FileTimeFlag::from_cli(&cli);
+    }
+
+    #[test]
+    fn test_from_cli_classic_mode() {
+        let argv = ["lsd", "--ftime", "mtime", "--classic"];
+        let cli = Cli::try_parse_from(argv).unwrap();
+        assert_eq!(
+            Some(FileTimeFlag::Modification),
+            FileTimeFlag::from_cli(&cli)
+        );
+    }
+
+    #[test]
+    fn test_from_cli_ftime_multi() {
+        let argv = ["lsd", "--ftime", "mtime", "--ftime", "atime"];
+        let cli = Cli::try_parse_from(argv).unwrap();
+        assert_eq!(Some(FileTimeFlag::Access), FileTimeFlag::from_cli(&cli));
+    }
+
+    #[test]
+    fn test_from_config_none() {
+        assert_eq!(None, FileTimeFlag::from_config(&Config::with_none()));
+    }
+
+    #[test]
+    fn test_from_config_mtime() {
+        let mut c = Config::with_none();
+        c.ftime = Some("mtime".into());
+
+        assert_eq!(
+            Some(FileTimeFlag::Modification),
+            FileTimeFlag::from_config(&c)
+        );
+    }
+
+    #[test]
+    fn test_from_config_atime() {
+        let mut c = Config::with_none();
+        c.ftime = Some("atime".into());
+        assert_eq!(Some(FileTimeFlag::Access), FileTimeFlag::from_config(&c));
+    }
+
+    #[test]
+    fn test_from_config_btime() {
+        let mut c = Config::with_none();
+        c.ftime = Some("btime".into());
+        assert_eq!(Some(FileTimeFlag::Birth), FileTimeFlag::from_config(&c));
+    }
+
+    #[test]
+    fn test_from_config_classic_mode() {
+        let mut c = Config::with_none();
+        c.ftime = Some("atime".into());
+        c.classic = Some(true);
+        assert_eq!(
+            Some(FileTimeFlag::Modification),
+            FileTimeFlag::from_config(&c)
+        );
+    }
+
+    #[test]
+    #[serial_test::serial]
+    fn test_from_environment_none() {
+        std::env::set_var("LSD_FILE_TIME", "");
+        assert_eq!(None, FileTimeFlag::from_environment());
+    }
+
+    #[test]
+    #[serial_test::serial]
+    fn test_from_environment_mtime() {
+        std::env::set_var("LSD_FILE_TIME", "mtime");
+        assert_eq!(
+            Some(FileTimeFlag::Modification),
+            FileTimeFlag::from_environment()
+        );
+    }
+
+    #[test]
+    #[serial_test::serial]
+    fn test_from_environment_atime() {
+        std::env::set_var("LSD_FILE_TIME", "atime");
+        assert_eq!(Some(FileTimeFlag::Access), FileTimeFlag::from_environment());
+    }
+
+    #[test]
+    #[serial_test::serial]
+    fn test_from_environment_btime() {
+        std::env::set_var("LSD_FILE_TIME", "btime");
+        assert_eq!(Some(FileTimeFlag::Birth), FileTimeFlag::from_environment());
+    }
+
+    #[test]
+    #[serial_test::serial]
+    fn test_parsing_order_arg() {
+        std::env::set_var("LSD_FILE_TIME", "mtime");
+        let argv = ["lsd", "--ftime", "atime"];
+        let cli = Cli::try_parse_from(argv).unwrap();
+        let mut config = Config::with_none();
+        config.ftime = Some("btime".into());
+        assert_eq!(
+            FileTimeFlag::Access,
+            FileTimeFlag::configure_from(&cli, &config)
+        );
+    }
+
+    #[test]
+    #[serial_test::serial]
+    fn test_parsing_order_env() {
+        std::env::set_var("LSD_FILE_TIME", "mtime");
+        let argv = ["lsd"];
+        let cli = Cli::try_parse_from(argv).unwrap();
+        let mut config = Config::with_none();
+        config.ftime = Some("btime".into());
+        assert_eq!(
+            FileTimeFlag::Modification,
+            FileTimeFlag::configure_from(&cli, &config)
+        );
+    }
+
+    #[test]
+    #[serial_test::serial]
+    fn test_parsing_order_config() {
+        std::env::set_var("LSD_FILE_TIME", "");
+        let argv = ["lsd"];
+        let cli = Cli::try_parse_from(argv).unwrap();
+        let mut config = Config::with_none();
+        config.ftime = Some("btime".into());
+        assert_eq!(
+            FileTimeFlag::Birth,
+            FileTimeFlag::configure_from(&cli, &config)
+        );
+    }
+}
diff --git a/src/meta/date.rs b/src/meta/date.rs
index 007023c35..71ce1371d 100644
--- a/src/meta/date.rs
+++ b/src/meta/date.rs
@@ -25,7 +25,7 @@ impl From<SystemTime> for Date {
 
 impl From<&Metadata> for Date {
     fn from(meta: &Metadata) -> Self {
-        meta.modified()
+        meta.accessed()
             .expect("failed to retrieve modified date")
             .into()
     }

From ef1e6275a737fb724c728fc73b1cf66209782b22 Mon Sep 17 00:00:00 2001
From: Uggla <uggla@free.fr>
Date: Fri, 8 Nov 2024 22:22:14 +0100
Subject: [PATCH 2/2] Retrieve file timestamp (access time, birth time, and
 modification time) based on the arguments specified in the ftime command-line
 option.

---
 src/core.rs          |  17 +++----
 src/display.rs       |  30 ++++++-----
 src/icon.rs          |  35 ++++++++-----
 src/meta/date.rs     |  42 ++++++++-------
 src/meta/filetype.rs |   6 +--
 src/meta/mod.rs      |  29 ++++++-----
 src/meta/name.rs     |  11 ++--
 src/sort.rs          | 119 +++++++++++++++++++++++++------------------
 8 files changed, 171 insertions(+), 118 deletions(-)

diff --git a/src/core.rs b/src/core.rs
index 97472ec40..63219544b 100644
--- a/src/core.rs
+++ b/src/core.rs
@@ -116,15 +116,14 @@ impl Core {
             .collect();
 
         for path in paths {
-            let mut meta =
-                match Meta::from_path(&path, self.flags.dereference.0, self.flags.permission) {
-                    Ok(meta) => meta,
-                    Err(err) => {
-                        print_error!("{}: {}.", path.display(), err);
-                        exit_code.set_if_greater(ExitCode::MajorIssue);
-                        continue;
-                    }
-                };
+            let mut meta = match Meta::from_path(&path, self.flags.dereference.0, &self.flags) {
+                Ok(meta) => meta,
+                Err(err) => {
+                    print_error!("{}: {}.", path.display(), err);
+                    exit_code.set_if_greater(ExitCode::MajorIssue);
+                    continue;
+                }
+            };
 
             let cache = if self.flags.blocks.0.contains(&Block::GitStatus) {
                 Some(GitCache::new(&path))
diff --git a/src/display.rs b/src/display.rs
index ca037f0b7..56d87998e 100644
--- a/src/display.rs
+++ b/src/display.rs
@@ -504,7 +504,7 @@ mod tests {
     use crate::app::Cli;
     use crate::color;
     use crate::color::Colors;
-    use crate::flags::{HyperlinkOption, IconOption, IconTheme as FlagTheme, PermissionFlag};
+    use crate::flags::{HyperlinkOption, IconOption, IconTheme as FlagTheme};
     use crate::icon::Icons;
     use crate::meta::{FileType, Name};
     use crate::Config;
@@ -699,7 +699,7 @@ mod tests {
         dir.child("one.d").create_dir_all().unwrap();
         dir.child("one.d/two").touch().unwrap();
         dir.child("one.d/.hidden").touch().unwrap();
-        let mut metas = Meta::from_path(Path::new(dir.path()), false, PermissionFlag::Rwx)
+        let mut metas = Meta::from_path(Path::new(dir.path()), false, &flags)
             .unwrap()
             .recurse_into(42, &flags, None)
             .unwrap()
@@ -732,7 +732,7 @@ mod tests {
         let dir = assert_fs::TempDir::new().unwrap();
         dir.child("dir").create_dir_all().unwrap();
         dir.child("dir/file").touch().unwrap();
-        let metas = Meta::from_path(Path::new(dir.path()), false, PermissionFlag::Rwx)
+        let metas = Meta::from_path(Path::new(dir.path()), false, &flags)
             .unwrap()
             .recurse_into(42, &flags, None)
             .unwrap()
@@ -773,7 +773,7 @@ mod tests {
         let dir = assert_fs::TempDir::new().unwrap();
         dir.child("dir").create_dir_all().unwrap();
         dir.child("dir/file").touch().unwrap();
-        let metas = Meta::from_path(Path::new(dir.path()), false, PermissionFlag::Rwx)
+        let metas = Meta::from_path(Path::new(dir.path()), false, &flags)
             .unwrap()
             .recurse_into(42, &flags, None)
             .unwrap()
@@ -813,7 +813,7 @@ mod tests {
         let dir = assert_fs::TempDir::new().unwrap();
         dir.child("one.d").create_dir_all().unwrap();
         dir.child("one.d/two").touch().unwrap();
-        let metas = Meta::from_path(Path::new(dir.path()), false, PermissionFlag::Rwx)
+        let metas = Meta::from_path(Path::new(dir.path()), false, &flags)
             .unwrap()
             .recurse_into(42, &flags, None)
             .unwrap()
@@ -844,7 +844,7 @@ mod tests {
         let dir = assert_fs::TempDir::new().unwrap();
         dir.child("testdir").create_dir_all().unwrap();
         dir.child("test").touch().unwrap();
-        let metas = Meta::from_path(Path::new(dir.path()), false, PermissionFlag::Rwx)
+        let metas = Meta::from_path(Path::new(dir.path()), false, &flags)
             .unwrap()
             .recurse_into(1, &flags, None)
             .unwrap()
@@ -878,7 +878,7 @@ mod tests {
 
         let dir = assert_fs::TempDir::new().unwrap();
         dir.child("testdir").create_dir_all().unwrap();
-        let metas = Meta::from_path(Path::new(dir.path()), false, PermissionFlag::Rwx)
+        let metas = Meta::from_path(Path::new(dir.path()), false, &flags)
             .unwrap()
             .recurse_into(1, &flags, None)
             .unwrap()
@@ -908,11 +908,14 @@ mod tests {
 
         let file_path = tmp_dir.path().join("file");
         std::fs::File::create(&file_path).expect("failed to create the file");
-        let file = Meta::from_path(&file_path, false, PermissionFlag::Rwx).unwrap();
+
+        let flags = Flags::default();
+
+        let file = Meta::from_path(&file_path, false, &flags).unwrap();
 
         let dir_path = tmp_dir.path().join("dir");
         std::fs::create_dir(&dir_path).expect("failed to create the dir");
-        let dir = Meta::from_path(&dir_path, false, PermissionFlag::Rwx).unwrap();
+        let dir = Meta::from_path(&dir_path, false, &flags).unwrap();
 
         assert_eq!(
             display_folder_path(&dir),
@@ -955,15 +958,18 @@ mod tests {
 
         let file_path = tmp_dir.path().join("file");
         std::fs::File::create(&file_path).expect("failed to create the file");
-        let file = Meta::from_path(&file_path, false, PermissionFlag::Rwx).unwrap();
+
+        let flags = Flags::default();
+
+        let file = Meta::from_path(&file_path, false, &flags).unwrap();
 
         let dir_path = tmp_dir.path().join("dir");
         std::fs::create_dir(&dir_path).expect("failed to create the dir");
-        let dir = Meta::from_path(&dir_path, false, PermissionFlag::Rwx).unwrap();
+        let dir = Meta::from_path(&dir_path, false, &flags).unwrap();
 
         let link_path = tmp_dir.path().join("link");
         std::os::unix::fs::symlink("dir", &link_path).unwrap();
-        let link = Meta::from_path(&link_path, false, PermissionFlag::Rwx).unwrap();
+        let link = Meta::from_path(&link_path, false, &flags).unwrap();
 
         const YES: bool = true;
         const NO: bool = false;
diff --git a/src/icon.rs b/src/icon.rs
index 6fec005f2..3d50485fe 100644
--- a/src/icon.rs
+++ b/src/icon.rs
@@ -75,7 +75,7 @@ impl Icons {
 #[cfg(test)]
 mod test {
     use super::{IconTheme, Icons};
-    use crate::flags::{IconOption, IconTheme as FlagTheme, PermissionFlag};
+    use crate::flags::{Flags, IconOption, IconTheme as FlagTheme};
     use crate::meta::Meta;
     use std::fs::File;
     use tempfile::tempdir;
@@ -85,7 +85,8 @@ mod test {
         let tmp_dir = tempdir().expect("failed to create temp dir");
         let file_path = tmp_dir.path().join("file.txt");
         File::create(&file_path).expect("failed to create file");
-        let meta = Meta::from_path(&file_path, false, PermissionFlag::Rwx).unwrap();
+        let flags = Flags::default();
+        let meta = Meta::from_path(&file_path, false, &flags).unwrap();
 
         let icons = Icons::new(true, IconOption::Never, FlagTheme::Fancy, " ".to_string());
         let icon = icons.get(&meta.name);
@@ -97,7 +98,8 @@ mod test {
         let tmp_dir = tempdir().expect("failed to create temp dir");
         let file_path = tmp_dir.path().join("file.txt");
         File::create(&file_path).expect("failed to create file");
-        let meta = Meta::from_path(&file_path, false, PermissionFlag::Rwx).unwrap();
+        let flags = Flags::default();
+        let meta = Meta::from_path(&file_path, false, &flags).unwrap();
 
         let icons = Icons::new(false, IconOption::Never, FlagTheme::Fancy, " ".to_string());
         let icon = icons.get(&meta.name);
@@ -110,7 +112,8 @@ mod test {
         let tmp_dir = tempdir().expect("failed to create temp dir");
         let file_path = tmp_dir.path().join("file.txt");
         File::create(&file_path).expect("failed to create file");
-        let meta = Meta::from_path(&file_path, false, PermissionFlag::Rwx).unwrap();
+        let flags = Flags::default();
+        let meta = Meta::from_path(&file_path, false, &flags).unwrap();
 
         let icons = Icons::new(false, IconOption::Auto, FlagTheme::Fancy, " ".to_string());
         let icon = icons.get(&meta.name);
@@ -122,7 +125,8 @@ mod test {
         let tmp_dir = tempdir().expect("failed to create temp dir");
         let file_path = tmp_dir.path().join("file.txt");
         File::create(&file_path).expect("failed to create file");
-        let meta = Meta::from_path(&file_path, false, PermissionFlag::Rwx).unwrap();
+        let flags = Flags::default();
+        let meta = Meta::from_path(&file_path, false, &flags).unwrap();
 
         let icons = Icons::new(true, IconOption::Auto, FlagTheme::Fancy, " ".to_string());
         let icon = icons.get(&meta.name);
@@ -135,7 +139,8 @@ mod test {
         let tmp_dir = tempdir().expect("failed to create temp dir");
         let file_path = tmp_dir.path().join("file");
         File::create(&file_path).expect("failed to create file");
-        let meta = Meta::from_path(&file_path, false, PermissionFlag::Rwx).unwrap();
+        let flags = Flags::default();
+        let meta = Meta::from_path(&file_path, false, &flags).unwrap();
 
         let icon = Icons::new(true, IconOption::Always, FlagTheme::Fancy, " ".to_string());
         let icon_str = icon.get(&meta.name);
@@ -148,7 +153,8 @@ mod test {
         let tmp_dir = tempdir().expect("failed to create temp dir");
         let file_path = tmp_dir.path().join("file");
         File::create(&file_path).expect("failed to create file");
-        let meta = Meta::from_path(&file_path, false, PermissionFlag::Rwx).unwrap();
+        let flags = Flags::default();
+        let meta = Meta::from_path(&file_path, false, &flags).unwrap();
 
         let icon = Icons::new(false, IconOption::Always, FlagTheme::Fancy, " ".to_string());
         let icon_str = icon.get(&meta.name);
@@ -161,7 +167,8 @@ mod test {
         let tmp_dir = tempdir().expect("failed to create temp dir");
         let file_path = tmp_dir.path().join("file");
         File::create(&file_path).expect("failed to create file");
-        let meta = Meta::from_path(&file_path, false, PermissionFlag::Rwx).unwrap();
+        let flags = Flags::default();
+        let meta = Meta::from_path(&file_path, false, &flags).unwrap();
 
         let icon = Icons::new(
             false,
@@ -178,7 +185,8 @@ mod test {
     fn get_icon_default_directory() {
         let tmp_dir = tempdir().expect("failed to create temp dir");
         let file_path = tmp_dir.path();
-        let meta = Meta::from_path(file_path, false, PermissionFlag::Rwx).unwrap();
+        let flags = Flags::default();
+        let meta = Meta::from_path(file_path, false, &flags).unwrap();
 
         let icon = Icons::new(false, IconOption::Always, FlagTheme::Fancy, " ".to_string());
         let icon_str = icon.get(&meta.name);
@@ -190,7 +198,8 @@ mod test {
     fn get_icon_default_directory_unicode() {
         let tmp_dir = tempdir().expect("failed to create temp dir");
         let file_path = tmp_dir.path();
-        let meta = Meta::from_path(file_path, false, PermissionFlag::Rwx).unwrap();
+        let flags = Flags::default();
+        let meta = Meta::from_path(file_path, false, &flags).unwrap();
 
         let icon = Icons::new(
             false,
@@ -210,7 +219,8 @@ mod test {
         for (file_name, file_icon) in &IconTheme::get_default_icons_by_name() {
             let file_path = tmp_dir.path().join(file_name);
             File::create(&file_path).expect("failed to create file");
-            let meta = Meta::from_path(&file_path, false, PermissionFlag::Rwx).unwrap();
+            let flags = Flags::default();
+            let meta = Meta::from_path(&file_path, false, &flags).unwrap();
 
             let icon = Icons::new(false, IconOption::Always, FlagTheme::Fancy, " ".to_string());
             let icon_str = icon.get(&meta.name);
@@ -226,7 +236,8 @@ mod test {
         for (ext, file_icon) in &IconTheme::get_default_icons_by_extension() {
             let file_path = tmp_dir.path().join(format!("file.{ext}"));
             File::create(&file_path).expect("failed to create file");
-            let meta = Meta::from_path(&file_path, false, PermissionFlag::Rwx).unwrap();
+            let flags = Flags::default();
+            let meta = Meta::from_path(&file_path, false, &flags).unwrap();
 
             let icon = Icons::new(false, IconOption::Always, FlagTheme::Fancy, " ".to_string());
             let icon_str = icon.get(&meta.name);
diff --git a/src/meta/date.rs b/src/meta/date.rs
index 71ce1371d..e28f1d1b4 100644
--- a/src/meta/date.rs
+++ b/src/meta/date.rs
@@ -1,6 +1,6 @@
 use super::locale::current_locale;
 use crate::color::{ColoredString, Colors, Elem};
-use crate::flags::{DateFlag, Flags};
+use crate::flags::{DateFlag, FileTimeFlag, Flags};
 use chrono::{DateTime, Duration, Local};
 use chrono_humanize::HumanTime;
 use std::fs::Metadata;
@@ -23,15 +23,23 @@ impl From<SystemTime> for Date {
     }
 }
 
-impl From<&Metadata> for Date {
-    fn from(meta: &Metadata) -> Self {
-        meta.accessed()
-            .expect("failed to retrieve modified date")
-            .into()
-    }
-}
-
 impl Date {
+    pub fn from_metadata(meta: &Metadata, flags: &Flags) -> Self {
+        match flags.ftime {
+            FileTimeFlag::Birth => meta
+                .created()
+                .expect("failed to retrieve creation date")
+                .into(),
+            FileTimeFlag::Access => meta
+                .accessed()
+                .expect("failed to retrieve access date")
+                .into(),
+            FileTimeFlag::Modification => meta
+                .modified()
+                .expect("failed to retrieve modification date")
+                .into(),
+        }
+    }
     pub fn render(&self, colors: &Colors, flags: &Flags) -> ColoredString {
         let now = Local::now();
         #[allow(deprecated)]
@@ -130,7 +138,7 @@ mod test {
         assert!(success, "failed to exec touch");
 
         let colors = Colors::new(ThemeOption::Default);
-        let date = Date::from(&file_path.metadata().unwrap());
+        let date = Date::from_metadata(&file_path.metadata().unwrap(), &Flags::default());
         let flags = Flags::default();
 
         assert_eq!(
@@ -158,7 +166,7 @@ mod test {
         assert!(success, "failed to exec touch");
 
         let colors = Colors::new(ThemeOption::Default);
-        let date = Date::from(&file_path.metadata().unwrap());
+        let date = Date::from_metadata(&file_path.metadata().unwrap(), &Flags::default());
         let flags = Flags::default();
 
         assert_eq!(
@@ -186,7 +194,7 @@ mod test {
         assert!(success, "failed to exec touch");
 
         let colors = Colors::new(ThemeOption::Default);
-        let date = Date::from(&file_path.metadata().unwrap());
+        let date = Date::from_metadata(&file_path.metadata().unwrap(), &Flags::default());
         let flags = Flags::default();
 
         assert_eq!(
@@ -214,7 +222,7 @@ mod test {
         assert!(success, "failed to exec touch");
 
         let colors = Colors::new(ThemeOption::Default);
-        let date = Date::from(&file_path.metadata().unwrap());
+        let date = Date::from_metadata(&file_path.metadata().unwrap(), &Flags::default());
 
         let flags = Flags {
             date: DateFlag::Relative,
@@ -241,7 +249,7 @@ mod test {
         assert!(success, "failed to exec touch");
 
         let colors = Colors::new(ThemeOption::Default);
-        let date = Date::from(&file_path.metadata().unwrap());
+        let date = Date::from_metadata(&file_path.metadata().unwrap(), &Flags::default());
 
         let flags = Flags {
             date: DateFlag::Relative,
@@ -268,7 +276,7 @@ mod test {
         assert!(success, "failed to exec touch");
 
         let colors = Colors::new(ThemeOption::Default);
-        let date = Date::from(&file_path.metadata().unwrap());
+        let date = Date::from_metadata(&file_path.metadata().unwrap(), &Flags::default());
 
         let flags = Flags {
             date: DateFlag::Iso,
@@ -299,7 +307,7 @@ mod test {
         assert!(success, "failed to exec touch");
 
         let colors = Colors::new(ThemeOption::Default);
-        let date = Date::from(&file_path.metadata().unwrap());
+        let date = Date::from_metadata(&file_path.metadata().unwrap(), &Flags::default());
 
         let flags = Flags {
             date: DateFlag::Iso,
@@ -329,7 +337,7 @@ mod test {
         assert!(success, "failed to exec touch");
 
         let colors = Colors::new(ThemeOption::Default);
-        let date = Date::from(&file_path.metadata().unwrap());
+        let date = Date::from_metadata(&file_path.metadata().unwrap(), &Flags::default());
 
         let flags = Flags {
             date: DateFlag::Locale,
diff --git a/src/meta/filetype.rs b/src/meta/filetype.rs
index 07ca8ab2f..9611bc32f 100644
--- a/src/meta/filetype.rs
+++ b/src/meta/filetype.rs
@@ -109,8 +109,7 @@ impl FileType {
 mod test {
     use super::FileType;
     use crate::color::{Colors, ThemeOption};
-    #[cfg(unix)]
-    use crate::flags::PermissionFlag;
+    use crate::flags::Flags;
     #[cfg(unix)]
     use crate::meta::permissions_or_attributes::PermissionsOrAttributes;
     #[cfg(unix)]
@@ -148,7 +147,8 @@ mod test {
     fn test_dir_type() {
         let tmp_dir = tempdir().expect("failed to create temp dir");
         #[cfg(not(windows))]
-        let meta = crate::meta::Meta::from_path(tmp_dir.path(), false, PermissionFlag::Rwx)
+        let flags = Flags::default();
+        let meta = crate::meta::Meta::from_path(tmp_dir.path(), false, &flags)
             .expect("failed to get tempdir path");
         let metadata = tmp_dir.path().metadata().expect("failed to get metas");
 
diff --git a/src/meta/mod.rs b/src/meta/mod.rs
index e8384fd19..48bbc1f08 100644
--- a/src/meta/mod.rs
+++ b/src/meta/mod.rs
@@ -103,7 +103,7 @@ impl Meta {
             let mut parent_meta = Self::from_path(
                 &self.path.join(Component::ParentDir),
                 flags.dereference.0,
-                flags.permission,
+                flags,
             )?;
             "..".clone_into(&mut parent_meta.name.name);
 
@@ -147,8 +147,7 @@ impl Meta {
                 _ => {}
             }
 
-            let mut entry_meta = match Self::from_path(&path, flags.dereference.0, flags.permission)
-            {
+            let mut entry_meta = match Self::from_path(&path, flags.dereference.0, flags) {
                 Ok(res) => res,
                 Err(err) => {
                     print_error!("{}: {}.", path.display(), err);
@@ -261,7 +260,8 @@ impl Meta {
     pub fn from_path(
         path: &Path,
         dereference: bool,
-        permission_flag: PermissionFlag,
+        // permission_flag: PermissionFlag,
+        flags: &Flags,
     ) -> io::Result<Self> {
         let mut metadata = path.symlink_metadata()?;
         let mut symlink_meta = None;
@@ -287,7 +287,7 @@ impl Meta {
         }
 
         #[cfg(unix)]
-        let (owner, permissions) = match permission_flag {
+        let (owner, permissions) = match flags.permission {
             PermissionFlag::Disable => (None, None),
             _ => (
                 Some(Owner::from(&metadata)),
@@ -341,7 +341,7 @@ impl Meta {
                     Some(INode::from(&metadata)),
                     Some(Links::from(&metadata)),
                     Some(Size::from(&metadata)),
-                    Some(Date::from(&metadata)),
+                    Some(Date::from_metadata(&metadata, flags)),
                     Some(owner),
                     Some(permissions_or_attributes),
                     Some(AccessControl::for_path(path)),
@@ -369,6 +369,7 @@ impl Meta {
 
 #[cfg(test)]
 mod tests {
+    use crate::flags::Flags;
     use crate::flags::PermissionFlag;
 
     use super::Meta;
@@ -379,14 +380,19 @@ mod tests {
     #[test]
     fn test_from_path_path() {
         let dir = assert_fs::TempDir::new().unwrap();
-        let meta = Meta::from_path(dir.path(), false, PermissionFlag::Rwx).unwrap();
+        let flags = Flags::default();
+        let meta = Meta::from_path(dir.path(), false, &flags).unwrap();
         assert_eq!(meta.path, dir.path())
     }
 
     #[test]
     fn test_from_path_disable_permission() {
         let dir = assert_fs::TempDir::new().unwrap();
-        let meta = Meta::from_path(dir.path(), false, PermissionFlag::Disable).unwrap();
+        let flags = Flags {
+            permission: PermissionFlag::Disable,
+            ..Flags::default()
+        };
+        let meta = Meta::from_path(dir.path(), false, &flags).unwrap();
         assert!(meta.permissions_or_attributes.is_none());
         assert!(meta.owner.is_none());
     }
@@ -397,8 +403,8 @@ mod tests {
 
         let path_a = tmp_dir.path().join("aaa.aa");
         File::create(&path_a).expect("failed to create file");
-        let meta_a =
-            Meta::from_path(&path_a, false, PermissionFlag::Rwx).expect("failed to get meta");
+        let flags = Flags::default();
+        let meta_a = Meta::from_path(&path_a, false, &flags).expect("failed to get meta");
 
         let path_b = tmp_dir.path().join("bbb.bb");
         let path_c = tmp_dir.path().join("ccc.cc");
@@ -413,8 +419,7 @@ mod tests {
         std::os::windows::fs::symlink_file(path_c, &path_b)
             .expect("failed to create broken symlink");
 
-        let meta_b =
-            Meta::from_path(&path_b, true, PermissionFlag::Rwx).expect("failed to get meta");
+        let meta_b = Meta::from_path(&path_b, true, &flags).expect("failed to get meta");
 
         assert!(
             meta_a.inode.is_some()
diff --git a/src/meta/name.rs b/src/meta/name.rs
index 788c8907e..28f79b2be 100644
--- a/src/meta/name.rs
+++ b/src/meta/name.rs
@@ -220,7 +220,7 @@ mod test {
     use super::DisplayOption;
     use super::Name;
     use crate::color::{self, Colors};
-    use crate::flags::PermissionFlag;
+    use crate::flags::Flags;
     use crate::flags::{HyperlinkOption, IconOption, IconTheme as FlagTheme};
     use crate::icon::Icons;
     use crate::meta::FileType;
@@ -273,7 +273,8 @@ mod test {
         // Create the directory
         let dir_path = tmp_dir.path().join("directory");
         fs::create_dir(&dir_path).expect("failed to create the dir");
-        let meta = Meta::from_path(&dir_path, false, PermissionFlag::Rwx).unwrap();
+        let flags = Flags::default();
+        let meta = Meta::from_path(&dir_path, false, &flags).unwrap();
 
         let colors = Colors::new(color::ThemeOption::NoLscolors);
 
@@ -397,7 +398,8 @@ mod test {
         // Create the file;
         let file_path = tmp_dir.path().join("file.txt");
         File::create(&file_path).expect("failed to create file");
-        let meta = Meta::from_path(&file_path, false, PermissionFlag::Rwx).unwrap();
+        let flags = Flags::default();
+        let meta = Meta::from_path(&file_path, false, &flags).unwrap();
 
         let colors = Colors::new(color::ThemeOption::NoColor);
 
@@ -423,7 +425,8 @@ mod test {
         // Create the file;
         let file_path = tmp_dir.path().join("file.txt");
         File::create(&file_path).expect("failed to create file");
-        let meta = Meta::from_path(&file_path, false, PermissionFlag::Rwx).unwrap();
+        let flags = Flags::default();
+        let meta = Meta::from_path(&file_path, false, &flags).unwrap();
 
         let colors = Colors::new(color::ThemeOption::NoColor);
 
diff --git a/src/sort.rs b/src/sort.rs
index 34deb948d..07478926c 100644
--- a/src/sort.rs
+++ b/src/sort.rs
@@ -80,7 +80,7 @@ fn by_git_status(a: &Meta, b: &Meta) -> Ordering {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::flags::{Flags, PermissionFlag};
+    use crate::flags::{FileTimeFlag, Flags};
     use std::fs::{create_dir, File};
     use std::io::prelude::*;
     use std::process::Command;
@@ -93,14 +93,13 @@ mod tests {
         // Create the file;
         let path_a = tmp_dir.path().join("zzz");
         File::create(&path_a).expect("failed to create file");
-        let meta_a =
-            Meta::from_path(&path_a, false, PermissionFlag::Rwx).expect("failed to get meta");
+        let flags = Flags::default();
+        let meta_a = Meta::from_path(&path_a, false, &flags).expect("failed to get meta");
 
         // Create a dir;
         let path_z = tmp_dir.path().join("aaa");
         create_dir(&path_z).expect("failed to create dir");
-        let meta_z =
-            Meta::from_path(&path_z, false, PermissionFlag::Rwx).expect("failed to get meta");
+        let meta_z = Meta::from_path(&path_z, false, &flags).expect("failed to get meta");
 
         let mut flags = Flags::default();
         flags.sorting.dir_grouping = DirGrouping::First;
@@ -123,14 +122,13 @@ mod tests {
         // Create the file;
         let path_a = tmp_dir.path().join("zzz");
         File::create(&path_a).expect("failed to create file");
-        let meta_a =
-            Meta::from_path(&path_a, false, PermissionFlag::Rwx).expect("failed to get meta");
+        let flags = Flags::default();
+        let meta_a = Meta::from_path(&path_a, false, &flags).expect("failed to get meta");
 
         // Create a dir;
         let path_z = tmp_dir.path().join("aaa");
         create_dir(&path_z).expect("failed to create dir");
-        let meta_z =
-            Meta::from_path(&path_z, false, PermissionFlag::Rwx).expect("failed to get meta");
+        let meta_z = Meta::from_path(&path_z, false, &flags).expect("failed to get meta");
 
         let mut flags = Flags::default();
         flags.sorting.dir_grouping = DirGrouping::Last;
@@ -151,14 +149,13 @@ mod tests {
         // Create the file;
         let path_a = tmp_dir.path().join("aaa");
         File::create(&path_a).expect("failed to create file");
-        let meta_a =
-            Meta::from_path(&path_a, false, PermissionFlag::Rwx).expect("failed to get meta");
+        let flags = Flags::default();
+        let meta_a = Meta::from_path(&path_a, false, &flags).expect("failed to get meta");
 
         // Create a dir;
         let path_z = tmp_dir.path().join("zzz");
         create_dir(&path_z).expect("failed to create dir");
-        let meta_z =
-            Meta::from_path(&path_z, false, PermissionFlag::Rwx).expect("failed to get meta");
+        let meta_z = Meta::from_path(&path_z, false, &flags).expect("failed to get meta");
 
         let mut flags = Flags::default();
         flags.sorting.dir_grouping = DirGrouping::None;
@@ -181,14 +178,13 @@ mod tests {
         // Create the file;
         let path_a = tmp_dir.path().join("zzz");
         File::create(&path_a).expect("failed to create file");
-        let meta_a =
-            Meta::from_path(&path_a, false, PermissionFlag::Rwx).expect("failed to get meta");
+        let flags = Flags::default();
+        let meta_a = Meta::from_path(&path_a, false, &flags).expect("failed to get meta");
 
         // Create a dir;
         let path_z = tmp_dir.path().join("aaa");
         create_dir(&path_z).expect("failed to create dir");
-        let meta_z =
-            Meta::from_path(&path_z, false, PermissionFlag::Rwx).expect("failed to get meta");
+        let meta_z = Meta::from_path(&path_z, false, &flags).expect("failed to get meta");
 
         let mut flags = Flags::default();
         flags.sorting.dir_grouping = DirGrouping::None;
@@ -211,10 +207,11 @@ mod tests {
         // Create the file;
         let path_a = tmp_dir.path().join("aaa");
         File::create(&path_a).expect("failed to create file");
-        let meta_a =
-            Meta::from_path(&path_a, false, PermissionFlag::Rwx).expect("failed to get meta");
+        let flags = Flags::default();
+        let meta_a = Meta::from_path(&path_a, false, &flags).expect("failed to get meta");
 
         // Create the file;
+        std::thread::sleep(std::time::Duration::from_secs(1));
         let path_z = tmp_dir.path().join("zzz");
         File::create(&path_z).expect("failed to create file");
 
@@ -238,8 +235,7 @@ mod tests {
             .success();
 
         assert!(success, "failed to change file timestamp");
-        let meta_z =
-            Meta::from_path(&path_z, false, PermissionFlag::Rwx).expect("failed to get meta");
+        let meta_z = Meta::from_path(&path_z, false, &flags).expect("failed to get meta");
 
         let mut flags = Flags::default();
         flags.sorting.column = SortColumn::Time;
@@ -252,6 +248,41 @@ mod tests {
         flags.sorting.order = SortOrder::Reverse;
         let sorter = assemble_sorters(&flags);
         assert_eq!(by_meta(&sorter, &meta_a, &meta_z), Ordering::Greater);
+
+        // Sort by birth time
+        flags.sorting.order = SortOrder::Default;
+        flags.ftime = FileTimeFlag::Birth;
+        let meta_a = Meta::from_path(&path_a, false, &flags).expect("failed to get meta");
+        let meta_z = Meta::from_path(&path_z, false, &flags).expect("failed to get meta");
+        let sorter = assemble_sorters(&flags);
+        assert_eq!(by_meta(&sorter, &meta_a, &meta_z), Ordering::Greater);
+
+        // Sort by modification time
+        flags.sorting.order = SortOrder::Default;
+        flags.ftime = FileTimeFlag::Modification;
+        let meta_a = Meta::from_path(&path_a, false, &flags).expect("failed to get meta");
+        let meta_z = Meta::from_path(&path_z, false, &flags).expect("failed to get meta");
+        let sorter = assemble_sorters(&flags);
+        assert_eq!(by_meta(&sorter, &meta_a, &meta_z), Ordering::Less);
+
+        // Sort by access time
+        flags.sorting.order = SortOrder::Default;
+        flags.ftime = FileTimeFlag::Access;
+        let meta_a = Meta::from_path(&path_a, false, &flags).expect("failed to get meta");
+        let meta_z = Meta::from_path(&path_z, false, &flags).expect("failed to get meta");
+        let sorter = assemble_sorters(&flags);
+        assert_eq!(by_meta(&sorter, &meta_a, &meta_z), Ordering::Less);
+
+        // Read the z file to change access time
+        let mut file_z = File::open(&path_z).expect("failed to open file");
+        let mut buf: Vec<u8> = Vec::new();
+        let _ = file_z.read_to_end(&mut buf).expect("failed to read file");
+
+        flags.ftime = FileTimeFlag::Access;
+        let meta_a = Meta::from_path(&path_a, false, &flags).expect("failed to get meta");
+        let meta_z = Meta::from_path(&path_z, false, &flags).expect("failed to get meta");
+        let sorter = assemble_sorters(&flags);
+        assert_eq!(by_meta(&sorter, &meta_a, &meta_z), Ordering::Greater);
     }
 
     #[test]
@@ -261,26 +292,23 @@ mod tests {
         // Create the file with rs extension;
         let path_a = tmp_dir.path().join("aaa.rs");
         File::create(&path_a).expect("failed to create file");
-        let meta_a =
-            Meta::from_path(&path_a, false, PermissionFlag::Rwx).expect("failed to get meta");
+        let flags = Flags::default();
+        let meta_a = Meta::from_path(&path_a, false, &flags).expect("failed to get meta");
 
         // Create the file with rs extension;
         let path_z = tmp_dir.path().join("zzz.rs");
         File::create(&path_z).expect("failed to create file");
-        let meta_z =
-            Meta::from_path(&path_z, false, PermissionFlag::Rwx).expect("failed to get meta");
+        let meta_z = Meta::from_path(&path_z, false, &flags).expect("failed to get meta");
 
         // Create the file with js extension;
         let path_j = tmp_dir.path().join("zzz.js");
         File::create(&path_j).expect("failed to create file");
-        let meta_j =
-            Meta::from_path(&path_j, false, PermissionFlag::Rwx).expect("failed to get meta");
+        let meta_j = Meta::from_path(&path_j, false, &flags).expect("failed to get meta");
 
         // Create the file with txt extension;
         let path_t = tmp_dir.path().join("zzz.txt");
         File::create(&path_t).expect("failed to create file");
-        let meta_t =
-            Meta::from_path(&path_t, false, PermissionFlag::Rwx).expect("failed to get meta");
+        let meta_t = Meta::from_path(&path_t, false, &flags).expect("failed to get meta");
 
         let mut flags = Flags::default();
         flags.sorting.column = SortColumn::Extension;
@@ -302,18 +330,16 @@ mod tests {
 
         let path_a = tmp_dir.path().join("2");
         File::create(&path_a).expect("failed to create file");
-        let meta_a =
-            Meta::from_path(&path_a, false, PermissionFlag::Rwx).expect("failed to get meta");
+        let flags = Flags::default();
+        let meta_a = Meta::from_path(&path_a, false, &flags).expect("failed to get meta");
 
         let path_b = tmp_dir.path().join("11");
         File::create(&path_b).expect("failed to create file");
-        let meta_b =
-            Meta::from_path(&path_b, false, PermissionFlag::Rwx).expect("failed to get meta");
+        let meta_b = Meta::from_path(&path_b, false, &flags).expect("failed to get meta");
 
         let path_c = tmp_dir.path().join("12");
         File::create(&path_c).expect("failed to create file");
-        let meta_c =
-            Meta::from_path(&path_c, false, PermissionFlag::Rwx).expect("failed to get meta");
+        let meta_c = Meta::from_path(&path_c, false, &flags).expect("failed to get meta");
 
         let mut flags = Flags::default();
         flags.sorting.column = SortColumn::Version;
@@ -331,23 +357,20 @@ mod tests {
 
         let path_a = tmp_dir.path().join("aaa.aa");
         File::create(&path_a).expect("failed to create file");
-        let meta_a =
-            Meta::from_path(&path_a, false, PermissionFlag::Rwx).expect("failed to get meta");
+        let flags = Flags::default();
+        let meta_a = Meta::from_path(&path_a, false, &flags).expect("failed to get meta");
 
         let path_b = tmp_dir.path().join("aaa");
         create_dir(&path_b).expect("failed to create dir");
-        let meta_b =
-            Meta::from_path(&path_b, false, PermissionFlag::Rwx).expect("failed to get meta");
+        let meta_b = Meta::from_path(&path_b, false, &flags).expect("failed to get meta");
 
         let path_c = tmp_dir.path().join("zzz.zz");
         File::create(&path_c).expect("failed to create file");
-        let meta_c =
-            Meta::from_path(&path_c, false, PermissionFlag::Rwx).expect("failed to get meta");
+        let meta_c = Meta::from_path(&path_c, false, &flags).expect("failed to get meta");
 
         let path_d = tmp_dir.path().join("zzz");
         create_dir(&path_d).expect("failed to create dir");
-        let meta_d =
-            Meta::from_path(&path_d, false, PermissionFlag::Rwx).expect("failed to get meta");
+        let meta_d = Meta::from_path(&path_d, false, &flags).expect("failed to get meta");
 
         let mut flags = Flags::default();
         flags.sorting.column = SortColumn::None;
@@ -380,16 +403,15 @@ mod tests {
             .expect("failed to create file")
             .write_all(b"1, 2, 3")
             .expect("failed to write to file");
-        let meta_a =
-            Meta::from_path(&path_a, false, PermissionFlag::Rwx).expect("failed to get meta");
+        let flags = Flags::default();
+        let meta_a = Meta::from_path(&path_a, false, &flags).expect("failed to get meta");
 
         let path_b = tmp_dir.path().join("bbb.bb");
         File::create(&path_b)
             .expect("failed to create file")
             .write_all(b"1, 2, 3, 4, 5, 6, 7, 8, 9, 10")
             .expect("failed to write file");
-        let meta_b =
-            Meta::from_path(&path_b, false, PermissionFlag::Rwx).expect("failed to get meta");
+        let meta_b = Meta::from_path(&path_b, false, &flags).expect("failed to get meta");
 
         let path_c = tmp_dir.path().join("ccc.cc");
         let path_d = tmp_dir.path().join("ddd.dd");
@@ -404,8 +426,7 @@ mod tests {
         std::os::windows::fs::symlink_file(path_d, &path_c)
             .expect("failed to create broken symlink");
 
-        let meta_c =
-            Meta::from_path(&path_c, true, PermissionFlag::Rwx).expect("failed to get meta");
+        let meta_c = Meta::from_path(&path_c, true, &flags).expect("failed to get meta");
 
         assert_eq!(by_size(&meta_a, &meta_a), Ordering::Equal);
         assert_eq!(by_size(&meta_a, &meta_b), Ordering::Greater);