[actor #189] methods to get an actor signature at the current time

Author: Byron

Cargo.lock

@@ -18,6 +18,7 @@ serde1 = ["serde", "bstr/serde1"]
 all-features = true
 
 [dependencies]
+git-features = { version = "^0.16.0", path = "../git-features", features = ["time"] }
 quick-error = "2.0.0"
 btoi = "0.4.2"
 bstr = { version = "0.2.13", default-features = false, features = ["std"]}

git-actor/Cargo.toml

@@ -99,6 +99,75 @@ mod write {
     }
 }
 
+mod init {
+    use crate::{Signature, Time};
+    use bstr::BString;
+
+    impl Signature {
+        /// Return an actor identified `name` and `email` at the current local time, that is a time with a timezone offset from
+        /// UTC based on the hosts configuration.
+        pub fn now_local(
+            name: impl Into<BString>,
+            email: impl Into<BString>,
+        ) -> Result<Self, git_features::time::tz::Error> {
+            let offset = git_features::time::tz::current_utc_offset()?;
+            Ok(Signature {
+                name: name.into(),
+                email: email.into(),
+                time: Time {
+                    time: std::time::SystemTime::now()
+                        .duration_since(std::time::UNIX_EPOCH)
+                        .expect("the system time doesn't run backwards that much")
+                        .as_secs() as u32,
+                    offset,
+                    sign: offset.into(),
+                },
+            })
+        }
+
+        /// Return an actor identified `name` and `email` at the current local time, or UTC time if the current time zone could
+        /// not be obtained.
+        pub fn now_local_or_utc(name: impl Into<BString>, email: impl Into<BString>) -> Self {
+            let offset = git_features::time::tz::current_utc_offset().unwrap_or(0);
+            Signature {
+                name: name.into(),
+                email: email.into(),
+                time: Time {
+                    time: std::time::SystemTime::now()
+                        .duration_since(std::time::UNIX_EPOCH)
+                        .expect("the system time doesn't run backwards that much")
+                        .as_secs() as u32,
+                    offset,
+                    sign: offset.into(),
+                },
+            }
+        }
+
+        /// Return an actor identified by `name` and `email` at the current time in UTC.
+        ///
+        /// This would be most useful for bot users, otherwise the [`now_local()`][Signature::now_local()] method should be preferred.
+        pub fn now_utc(name: impl Into<BString>, email: impl Into<BString>) -> Self {
+            let utc_offset = 0;
+            Signature {
+                name: name.into(),
+                email: email.into(),
+                time: Time {
+                    time: seconds_since_epoch(),
+                    offset: utc_offset,
+                    sign: utc_offset.into(),
+                },
+            }
+        }
+    }
+
+    fn seconds_since_epoch() -> u32 {
+        std::time::SystemTime::now()
+            .duration_since(std::time::UNIX_EPOCH)
+            .expect("the system time doesn't run backwards that much")
+            .as_secs() as u32
+    }
+}
+
 ///
 mod decode;
 pub use decode::decode;

git-actor/src/signature/mod.rs

@@ -2,6 +2,16 @@ use std::io;
 
 use crate::{Sign, Time, SPACE};
 
+impl From<i32> for Sign {
+    fn from(v: i32) -> Self {
+        if v < 0 {
+            Sign::Minus
+        } else {
+            Sign::Plus
+        }
+    }
+}
+
 impl Time {
     /// Serialize this instance to `out` in a format suitable for use in header fields of serialized git commits or tags.
     pub fn write_to(&self, mut out: impl io::Write) -> io::Result<()> {

git-actor/src/time.rs

@@ -1,9 +1,10 @@
 use std::path::PathBuf;
 
-mod signature;
-
 pub use git_testtools::hex_to_id;
 
 pub fn fixture(path: &str) -> PathBuf {
     PathBuf::from("tests/fixtures").join(path)
 }
+
+mod signature;
+mod time;

git-actor/tests/actor.rs

@@ -1,43 +1,3 @@
-mod time {
-    use bstr::ByteSlice;
-    use git_actor::{Sign, Time};
-
-    #[test]
-    fn write_to() -> Result<(), Box<dyn std::error::Error>> {
-        for (time, expected) in &[
-            (
-                Time {
-                    time: 500,
-                    offset: 9000,
-                    sign: Sign::Plus,
-                },
-                "500 +0230",
-            ),
-            (
-                Time {
-                    time: 189009009,
-                    offset: 36000,
-                    sign: Sign::Minus,
-                },
-                "189009009 -1000",
-            ),
-            (
-                Time {
-                    time: 0,
-                    offset: 0,
-                    sign: Sign::Minus,
-                },
-                "0 -0000",
-            ),
-        ] {
-            let mut output = Vec::new();
-            time.write_to(&mut output)?;
-            assert_eq!(output.as_bstr(), expected);
-        }
-        Ok(())
-    }
-}
-
 mod write_to {
     mod invalid {
         use git_actor::{Sign, Signature, Time};

git-actor/tests/signature/mod.rs

@@ -0,0 +1,37 @@
+use bstr::ByteSlice;
+use git_actor::{Sign, Time};
+
+#[test]
+fn write_to() -> Result<(), Box<dyn std::error::Error>> {
+    for (time, expected) in &[
+        (
+            Time {
+                time: 500,
+                offset: 9000,
+                sign: Sign::Plus,
+            },
+            "500 +0230",
+        ),
+        (
+            Time {
+                time: 189009009,
+                offset: 36000,
+                sign: Sign::Minus,
+            },
+            "189009009 -1000",
+        ),
+        (
+            Time {
+                time: 0,
+                offset: 0,
+                sign: Sign::Minus,
+            },
+            "0 -0000",
+        ),
+    ] {
+        let mut output = Vec::new();
+        time.write_to(&mut output)?;
+        assert_eq!(output.as_bstr(), expected);
+    }
+    Ok(())
+}

git-actor/tests/time/mod.rs

@@ -25,7 +25,9 @@ pub mod tz {
     /// Note that there may be various legitimate reasons for failure, which should be accounted for.
     pub fn current_utc_offset() -> Result<UTCOffsetInSeconds, Error> {
         // TODO: make this work without cfg(unsound_local_offset), see
-        // https://github.com/time-rs/time/issues/293#issuecomment-909158529
+        //       https://github.com/time-rs/time/issues/293#issuecomment-909158529
+        // TODO: get a function to return the current time as well to avoid double-lookups
+        //       (to get the offset, the current time is needed)
         time::UtcOffset::current_local_offset()
             .map(|ofs| ofs.whole_seconds())
             .map_err(|_| Error)