move more stuff - TODO

Author: sylvestre

Cargo.lock

@@ -18,7 +18,11 @@ use time::macros::{format_description, offset, time};
 use time::Duration;
 use uucore::display::Quotable;
 use uucore::error::{FromIo, UError, UResult, USimpleError};
+use uucore::parse_date;
+use uucore::parse_date_common::local_dt_to_filetime;
 use uucore::parse_relative_time;
+use uucore::parse_timestamp;
+
 use uucore::{format_usage, help_about, help_usage, show};
 
 const ABOUT: &str = help_about!("touch.md");
@@ -42,29 +46,6 @@ pub mod options {
 
 static ARG_FILES: &str = "files";
 
-// Convert a date/time to a date with a TZ offset
-fn to_local(tm: time::PrimitiveDateTime) -> time::OffsetDateTime {
-    let offset = match time::OffsetDateTime::now_local() {
-        Ok(lo) => lo.offset(),
-        Err(e) => {
-            panic!("error: {e}");
-        }
-    };
-    tm.assume_offset(offset)
-}
-
-// Convert a date/time with a TZ offset into a FileTime
-fn local_dt_to_filetime(dt: time::OffsetDateTime) -> FileTime {
-    FileTime::from_unix_time(dt.unix_timestamp(), dt.nanosecond())
-}
-
-// Convert a date/time, considering that the input is in UTC time
-// Used for touch -d 1970-01-01 18:43:33.023456789 for example
-fn dt_to_filename(tm: time::PrimitiveDateTime) -> FileTime {
-    let dt = tm.assume_offset(offset!(UTC));
-    local_dt_to_filetime(dt)
-}
-
 #[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     let matches = uu_app().try_get_matches_from(args)?;
@@ -108,21 +89,21 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
 
                 (atime, mtime)
             } else {
-                let timestamp = parse_date(date)?;
+                let timestamp = parse_date::from_str(date)?;
                 (timestamp, timestamp)
             }
         }
         (Some(reference), None) => {
             stat(Path::new(reference), !matches.get_flag(options::NO_DEREF))?
         }
         (None, Some(date)) => {
-            let timestamp = parse_date(date)?;
+            let timestamp = parse_date::from_str(date)?;
             (timestamp, timestamp)
         }
         (None, None) => {
             let timestamp =
                 if let Some(current) = matches.get_one::<String>(options::sources::CURRENT) {
-                    parse_timestamp(current)?
+                    parse_timestamp::from_str(current)?
                 } else {
                     local_dt_to_filetime(time::OffsetDateTime::now_local().unwrap())
                 };
@@ -320,192 +301,6 @@ fn stat(path: &Path, follow: bool) -> UResult<(FileTime, FileTime)> {
     ))
 }
 
-const POSIX_LOCALE_FORMAT: &[time::format_description::FormatItem] = format_description!(
-    "[weekday repr:short] [month repr:short] [day padding:space] \
-    [hour]:[minute]:[second] [year]"
-);
-
-const ISO_8601_FORMAT: &[time::format_description::FormatItem] =
-    format_description!("[year]-[month]-[day]");
-
-// "%Y%m%d%H%M.%S" 15 chars
-const YYYYMMDDHHMM_DOT_SS_FORMAT: &[time::format_description::FormatItem] = format_description!(
-    "[year repr:full][month repr:numerical padding:zero]\
-    [day][hour][minute].[second]"
-);
-
-// "%Y-%m-%d %H:%M:%S.%SS" 12 chars
-const YYYYMMDDHHMMSS_FORMAT: &[time::format_description::FormatItem] = format_description!(
-    "[year repr:full]-[month repr:numerical padding:zero]-\
-    [day] [hour]:[minute]:[second].[subsecond]"
-);
-
-// "%Y-%m-%d %H:%M:%S" 12 chars
-const YYYYMMDDHHMMS_FORMAT: &[time::format_description::FormatItem] = format_description!(
-    "[year repr:full]-[month repr:numerical padding:zero]-\
-    [day] [hour]:[minute]:[second]"
-);
-
-// "%Y-%m-%d %H:%M" 12 chars
-// Used for example in tests/touch/no-rights.sh
-const YYYY_MM_DD_HH_MM_FORMAT: &[time::format_description::FormatItem] = format_description!(
-    "[year repr:full]-[month repr:numerical padding:zero]-\
-    [day] [hour]:[minute]"
-);
-
-// "%Y%m%d%H%M" 12 chars
-const YYYYMMDDHHMM_FORMAT: &[time::format_description::FormatItem] = format_description!(
-    "[year repr:full][month repr:numerical padding:zero]\
-    [day][hour][minute]"
-);
-
-// "%y%m%d%H%M.%S" 13 chars
-const YYMMDDHHMM_DOT_SS_FORMAT: &[time::format_description::FormatItem] = format_description!(
-    "[year repr:last_two padding:none][month][day]\
-    [hour][minute].[second]"
-);
-
-// "%y%m%d%H%M" 10 chars
-const YYMMDDHHMM_FORMAT: &[time::format_description::FormatItem] = format_description!(
-    "[year repr:last_two padding:none][month padding:zero][day padding:zero]\
-    [hour repr:24 padding:zero][minute padding:zero]"
-);
-
-// "%Y-%m-%d %H:%M +offset"
-// Used for example in tests/touch/relative.sh
-const YYYYMMDDHHMM_OFFSET_FORMAT: &[time::format_description::FormatItem] = format_description!(
-    "[year]-[month]-[day] [hour repr:24]:[minute] \
-    [offset_hour sign:mandatory][offset_minute]"
-);
-
-fn parse_date(s: &str) -> UResult<FileTime> {
-    // This isn't actually compatible with GNU touch, but there doesn't seem to
-    // be any simple specification for what format this parameter allows and I'm
-    // not about to implement GNU parse_datetime.
-    // http://git.savannah.gnu.org/gitweb/?p=gnulib.git;a=blob_plain;f=lib/parse-datetime.y
-
-    // TODO: match on char count?
-
-    // "The preferred date and time representation for the current locale."
-    // "(In the POSIX locale this is equivalent to %a %b %e %H:%M:%S %Y.)"
-    // time 0.1.43 parsed this as 'a b e T Y'
-    // which is equivalent to the POSIX locale: %a %b %e %H:%M:%S %Y
-    // Tue Dec  3 ...
-    // ("%c", POSIX_LOCALE_FORMAT),
-    //
-    if let Ok(parsed) = time::PrimitiveDateTime::parse(s, &POSIX_LOCALE_FORMAT) {
-        return Ok(local_dt_to_filetime(to_local(parsed)));
-    }
-
-    // Also support other formats found in the GNU tests like
-    // in tests/misc/stat-nanoseconds.sh
-    // or tests/touch/no-rights.sh
-    for fmt in [
-        YYYYMMDDHHMMS_FORMAT,
-        YYYYMMDDHHMMSS_FORMAT,
-        YYYY_MM_DD_HH_MM_FORMAT,
-        YYYYMMDDHHMM_OFFSET_FORMAT,
-    ] {
-        if let Ok(parsed) = time::PrimitiveDateTime::parse(s, &fmt) {
-            return Ok(dt_to_filename(parsed));
-        }
-    }
-
-    // "Equivalent to %Y-%m-%d (the ISO 8601 date format). (C99)"
-    // ("%F", ISO_8601_FORMAT),
-    if let Ok(parsed) = time::Date::parse(s, &ISO_8601_FORMAT) {
-        return Ok(local_dt_to_filetime(to_local(
-            time::PrimitiveDateTime::new(parsed, time!(00:00)),
-        )));
-    }
-
-    // "@%s" is "The number of seconds since the Epoch, 1970-01-01 00:00:00 +0000 (UTC). (TZ) (Calculated from mktime(tm).)"
-    if s.bytes().next() == Some(b'@') {
-        if let Ok(ts) = &s[1..].parse::<i64>() {
-            // Don't convert to local time in this case - seconds since epoch are not time-zone dependent
-            return Ok(local_dt_to_filetime(
-                time::OffsetDateTime::from_unix_timestamp(*ts).unwrap(),
-            ));
-        }
-    }
-
-    if let Some(duration) = parse_relative_time::from_str(s) {
-        let now_local = time::OffsetDateTime::now_local().unwrap();
-        let diff = now_local.checked_add(duration).unwrap();
-        return Ok(local_dt_to_filetime(diff));
-    }
-
-    Err(USimpleError::new(1, format!("Unable to parse date: {s}")))
-}
-
-fn parse_timestamp(s: &str) -> UResult<FileTime> {
-    // TODO: handle error
-    let now = time::OffsetDateTime::now_utc();
-
-    let (mut format, mut ts) = match s.chars().count() {
-        15 => (YYYYMMDDHHMM_DOT_SS_FORMAT, s.to_owned()),
-        12 => (YYYYMMDDHHMM_FORMAT, s.to_owned()),
-        13 => (YYMMDDHHMM_DOT_SS_FORMAT, s.to_owned()),
-        10 => (YYMMDDHHMM_FORMAT, s.to_owned()),
-        11 => (YYYYMMDDHHMM_DOT_SS_FORMAT, format!("{}{}", now.year(), s)),
-        8 => (YYYYMMDDHHMM_FORMAT, format!("{}{}", now.year(), s)),
-        _ => {
-            return Err(USimpleError::new(
-                1,
-                format!("invalid date format {}", s.quote()),
-            ))
-        }
-    };
-    // workaround time returning Err(TryFromParsed(InsufficientInformation)) for year w/
-    // repr:last_two
-    // https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=1ccfac7c07c5d1c7887a11decf0e1996
-    if s.chars().count() == 10 {
-        format = YYYYMMDDHHMM_FORMAT;
-        ts = "20".to_owned() + &ts;
-    } else if s.chars().count() == 13 {
-        format = YYYYMMDDHHMM_DOT_SS_FORMAT;
-        ts = "20".to_owned() + &ts;
-    }
-
-    let leap_sec = if (format == YYYYMMDDHHMM_DOT_SS_FORMAT || format == YYMMDDHHMM_DOT_SS_FORMAT)
-        && ts.ends_with(".60")
-    {
-        // Work around to disable leap seconds
-        // Used in gnu/tests/touch/60-seconds
-        ts = ts.replace(".60", ".59");
-        true
-    } else {
-        false
-    };
-
-    let tm = time::PrimitiveDateTime::parse(&ts, &format)
-        .map_err(|_| USimpleError::new(1, format!("invalid date ts format {}", ts.quote())))?;
-    let mut local = to_local(tm);
-    if leap_sec {
-        // We are dealing with a leap second, add it
-        local = local.saturating_add(Duration::SECOND);
-    }
-    let ft = local_dt_to_filetime(local);
-
-    // // We have to check that ft is valid time. Due to daylight saving
-    // // time switch, local time can jump from 1:59 AM to 3:00 AM,
-    // // in which case any time between 2:00 AM and 2:59 AM is not valid.
-    // // Convert back to local time and see if we got the same value back.
-    // let ts = time::Timespec {
-    //     sec: ft.unix_seconds(),
-    //     nsec: 0,
-    // };
-    // let tm2 = time::at(ts);
-    // if tm.tm_hour != tm2.tm_hour {
-    //     return Err(USimpleError::new(
-    //         1,
-    //         format!("invalid date format {}", s.quote()),
-    //     ));
-    // }
-
-    Ok(ft)
-}
-
 // TODO: this may be a good candidate to put in fsext.rs
 /// Returns a PathBuf to stdout.
 ///

src/uu/touch/src/touch.rs

@@ -27,6 +27,7 @@ glob = "0.3.1"
 # * optional
 itertools = { version="0.10.5", optional=true }
 thiserror = { workspace=true, optional=true }
+filetime = { workspace=true }
 time = { workspace=true, optional=true, features = ["formatting", "local-offset", "macros"] }
 # * "problem" dependencies (pinned)
 data-encoding = { version="2.3", optional=true }

src/uucore/Cargo.toml

@@ -29,10 +29,13 @@ pub use crate::mods::ranges;
 pub use crate::mods::version_cmp;
 
 // * string parsing modules
+pub use crate::parser::parse_date;
+pub use crate::parser::parse_date_common;
 pub use crate::parser::parse_glob;
 pub use crate::parser::parse_relative_time;
 pub use crate::parser::parse_size;
 pub use crate::parser::parse_time;
+pub use crate::parser::parse_timestamp;
 
 // * feature-gated modules
 #[cfg(feature = "encoding")]

src/uucore/src/lib/lib.rs

@@ -1,4 +1,7 @@
+pub mod parse_date;
+pub mod parse_date_common;
 pub mod parse_glob;
 pub mod parse_relative_time;
 pub mod parse_size;
 pub mod parse_time;
+pub mod parse_timestamp;

src/uucore/src/lib/parser.rs

@@ -29,7 +29,8 @@ pub fn from_str(s: &str) -> UResult<FileTime> {
     // Tue Dec  3 ...
     // ("%c", POSIX_LOCALE_FORMAT),
     //
-    if let Ok(parsed) = time::OffsetDateTime::parse(s, &POSIX_LOCALE_FORMAT) {
+
+    if let Ok(parsed) = time::PrimitiveDateTime::parse(s, &POSIX_LOCALE_FORMAT) {
         return Ok(local_dt_to_filetime(to_local(parsed)));
     }
 
@@ -109,21 +110,18 @@ mod tests {
     #[test]
     fn test_from_str_iso_8601_format() {
         let s = "2023-04-23";
-        let expected = local_dt_to_filetime(
-            to_local(time::PrimitiveDateTime::new(
-                time::Date::parse(s, &ISO_8601_FORMAT).unwrap(),
-                time!(00:00),
-            )),
-        );
+        let expected = local_dt_to_filetime(to_local(time::PrimitiveDateTime::new(
+            time::Date::parse(s, &ISO_8601_FORMAT).unwrap(),
+            time!(00:00),
+        )));
         assert_file_time_eq(s, expected);
     }
 
     #[test]
     fn test_from_str_seconds_since_epoch() {
         let s = "@1609459200";
-        let expected = local_dt_to_filetime(
-            time::OffsetDateTime::from_unix_timestamp(1609459200).unwrap(),
-        );
+        let expected =
+            local_dt_to_filetime(time::OffsetDateTime::from_unix_timestamp(1609459200).unwrap());
         assert_file_time_eq(s, expected);
     }