git_index

Generates arguments to pass to stagit-index in descending order by commit date.
git clone https://git.philomathiclife.com/repos/git_index
Log | Files | Refs | README

main.rs (9374B)

      1 //! # `git_index`
      2 //!
      3 //! Consult [`README.md`](https://git.philomathiclife.com/git_index/file/README.md.html).
      4 #![deny(
      5     future_incompatible,
      6     let_underscore,
      7     missing_docs,
      8     nonstandard_style,
      9     rust_2018_compatibility,
     10     rust_2018_idioms,
     11     rust_2021_compatibility,
     12     rust_2024_compatibility,
     13     unsafe_code,
     14     unused,
     15     unused_crate_dependencies,
     16     warnings,
     17     clippy::all,
     18     clippy::cargo,
     19     clippy::complexity,
     20     clippy::correctness,
     21     clippy::nursery,
     22     clippy::pedantic,
     23     clippy::perf,
     24     clippy::restriction,
     25     clippy::style,
     26     clippy::suspicious
     27 )]
     28 #![expect(
     29     clippy::arbitrary_source_item_ordering,
     30     clippy::blanket_clippy_restriction_lints,
     31     clippy::implicit_return,
     32     clippy::min_ident_chars,
     33     clippy::missing_trait_methods,
     34     clippy::ref_patterns,
     35     clippy::return_and_then,
     36     clippy::question_mark_used,
     37     clippy::single_call_fn,
     38     reason = "noisy, opinionated, and likely doesn't prevent bugs or improve APIs"
     39 )]
     40 extern crate alloc;
     41 /// Module that parsed passed options into the application.
     42 mod args;
     43 use alloc::collections::BTreeMap;
     44 use args::{AbsDirPath, ArgsErr};
     45 #[cfg(not(target_os = "openbsd"))]
     46 use core::convert::Infallible;
     47 use core::{
     48     error,
     49     fmt::{self, Display, Formatter},
     50     str::{self, Utf8Error},
     51 };
     52 use jiff::{Error as TimeErr, Timestamp, fmt::temporal::DateTimeParser};
     53 #[cfg(target_os = "openbsd")]
     54 use priv_sep::{Permissions, Promise, Promises, UnveilErr};
     55 use std::{
     56     ffi::OsString,
     57     fs,
     58     io::{self, Error, Write as _},
     59     path::Path,
     60     process::{Command, Stdio},
     61 };
     62 /// `()` triggers lints when captured by `let`.
     63 /// This only relevant for the no-op functions.
     64 #[cfg(not(target_os = "openbsd"))]
     65 #[derive(Clone, Copy)]
     66 struct Zst;
     67 /// Module for reading the options passed to the application.
     68 /// Error returned from the program.
     69 enum E {
     70     /// Variant for errors due to incorrect arguments being passed.
     71     Args(ArgsErr),
     72     #[cfg(target_os = "openbsd")]
     73     /// Variant for errors due to calls to `unveil`.
     74     Unveil(UnveilErr),
     75     /// Variant for IO errors.
     76     Io(Error),
     77     /// Variant when a git repo directory is not valid UTF-8.
     78     NonUtf8Path(OsString),
     79     /// Variant when git errors.
     80     GitErr(Vec<u8>),
     81     /// Variant when git output is not valid UTF-8.
     82     Git(Utf8Error),
     83     /// Variant when git output is not a valid ISO 8601 timestamp.
     84     Time(TimeErr),
     85 }
     86 impl fmt::Debug for E {
     87     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
     88         <Self as Display>::fmt(self, f)
     89     }
     90 }
     91 impl Display for E {
     92     #[expect(
     93         clippy::use_debug,
     94         reason = "some contained errors don't implement Display"
     95     )]
     96     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
     97         match *self {
     98             Self::Args(ref e) => e.fmt(f),
     99             #[cfg(target_os = "openbsd")]
    100             Self::Unveil(ref err) => write!(f, "unveil(2) failed with {err}"),
    101             Self::Io(ref e) => e.fmt(f),
    102             Self::NonUtf8Path(ref e) => write!(f, "{e:?} is not valid UTF-8"),
    103             Self::GitErr(ref e) => match str::from_utf8(e.as_slice()) {
    104                 Ok(err) => write!(f, "git errored with: {err}"),
    105                 Err(err) => write!(f, "git errored with an invalid UTF-8 error: {err}"),
    106             },
    107             Self::Git(ref e) => write!(
    108                 f,
    109                 "git succeeded, but its output was not valid UTF-8: {e:?}"
    110             ),
    111             Self::Time(ref e) => write!(
    112                 f,
    113                 "git succeeded, but its output is not a valid ISO 8601 timestamp: {e}"
    114             ),
    115         }
    116     }
    117 }
    118 impl error::Error for E {}
    119 impl From<ArgsErr> for E {
    120     fn from(value: ArgsErr) -> Self {
    121         Self::Args(value)
    122     }
    123 }
    124 impl From<Error> for E {
    125     fn from(value: Error) -> Self {
    126         Self::Io(value)
    127     }
    128 }
    129 #[cfg(target_os = "openbsd")]
    130 impl From<UnveilErr> for E {
    131     fn from(value: UnveilErr) -> Self {
    132         Self::Unveil(value)
    133     }
    134 }
    135 #[cfg(not(target_os = "openbsd"))]
    136 impl From<Infallible> for E {
    137     fn from(value: Infallible) -> Self {
    138         match value {}
    139     }
    140 }
    141 impl From<Utf8Error> for E {
    142     fn from(value: Utf8Error) -> Self {
    143         Self::Git(value)
    144     }
    145 }
    146 impl From<OsString> for E {
    147     fn from(value: OsString) -> Self {
    148         Self::NonUtf8Path(value)
    149     }
    150 }
    151 impl From<TimeErr> for E {
    152     fn from(value: TimeErr) -> Self {
    153         Self::Time(value)
    154     }
    155 }
    156 /// Calls `pledge` with only the sys calls necessary for a minimal application
    157 /// to run. Specifically, the `Promise`s `Exec`, `Proc`, `Rpath`, `Stdio`, and `Unveil`
    158 /// are passed.
    159 #[cfg(target_os = "openbsd")]
    160 fn pledge_init() -> Result<Promises, Error> {
    161     let promises = Promises::new([
    162         Promise::Exec,
    163         Promise::Proc,
    164         Promise::Rpath,
    165         Promise::Stdio,
    166         Promise::Unveil,
    167     ]);
    168     match promises.pledge() {
    169         Ok(()) => Ok(promises),
    170         Err(e) => Err(e),
    171     }
    172 }
    173 /// No-op that returns `Ok`.
    174 #[expect(
    175     clippy::unnecessary_wraps,
    176     reason = "consistent API as openbsd feature"
    177 )]
    178 #[cfg(not(target_os = "openbsd"))]
    179 const fn pledge_init() -> Result<Zst, Infallible> {
    180     Ok(Zst)
    181 }
    182 /// Removes `Promise::Unveil`.
    183 #[cfg(target_os = "openbsd")]
    184 fn pledge_away_unveil(promises: &mut Promises) -> Result<(), Error> {
    185     promises.remove_then_pledge(Promise::Unveil)
    186 }
    187 /// No-op that returns `Ok`.
    188 #[expect(
    189     clippy::unnecessary_wraps,
    190     reason = "consistent API as openbsd feature"
    191 )]
    192 #[cfg(not(target_os = "openbsd"))]
    193 const fn pledge_away_unveil(_: &mut Zst) -> Result<(), Infallible> {
    194     Ok(())
    195 }
    196 /// Removes all `Promise`s except `Stdio`.
    197 #[cfg(target_os = "openbsd")]
    198 fn pledge_away_all_but_stdio(promises: &mut Promises) -> Result<(), Error> {
    199     promises.retain_then_pledge([Promise::Stdio])
    200 }
    201 /// No-op that returns `Ok`.
    202 #[expect(
    203     clippy::unnecessary_wraps,
    204     reason = "consistent API as openbsd feature"
    205 )]
    206 #[cfg(not(target_os = "openbsd"))]
    207 const fn pledge_away_all_but_stdio(_: &mut Zst) -> Result<(), Infallible> {
    208     Ok(())
    209 }
    210 /// Calls `unveil_none` on `/`.
    211 #[cfg(target_os = "openbsd")]
    212 fn veil_all() -> Result<(), UnveilErr> {
    213     Permissions::NONE.unveil("/")
    214 }
    215 /// No-op that returns `Ok`.
    216 #[expect(
    217     clippy::unnecessary_wraps,
    218     reason = "consistent API as openbsd feature"
    219 )]
    220 #[cfg(not(target_os = "openbsd"))]
    221 const fn veil_all() -> Result<(), Infallible> {
    222     Ok(())
    223 }
    224 /// Calls `unveil`_on `GIT` with `Permissions::EXECUTE`.
    225 #[cfg(target_os = "openbsd")]
    226 fn unveil_git() -> Result<(), UnveilErr> {
    227     Permissions::EXECUTE.unveil(GIT)
    228 }
    229 /// No-op that returns `Ok`.
    230 #[expect(
    231     clippy::unnecessary_wraps,
    232     reason = "consistent API as openbsd feature"
    233 )]
    234 #[cfg(not(target_os = "openbsd"))]
    235 const fn unveil_git() -> Result<(), Infallible> {
    236     Ok(())
    237 }
    238 /// Calls `unveil`_on `path` with `Permissions::READ`.
    239 #[cfg(target_os = "openbsd")]
    240 fn unveil_read<P: AsRef<Path>>(path: P) -> Result<(), UnveilErr> {
    241     Permissions::READ.unveil(path)
    242 }
    243 /// No-op that returns `Ok`.
    244 #[expect(
    245     clippy::unnecessary_wraps,
    246     reason = "consistent API as openbsd feature"
    247 )]
    248 #[cfg(not(target_os = "openbsd"))]
    249 fn unveil_read<P: AsRef<Path>>(_: P) -> Result<(), Infallible> {
    250     Ok(())
    251 }
    252 /// For each entry in `dir`, `git` is forked and invoked with `-C <dir><entry_in_dir> log -1 --date=iso-strict --pretty=format:"%cd"`.
    253 fn get_git_data(map: &mut BTreeMap<Timestamp, Vec<String>>, dir: AbsDirPath) -> Result<(), E> {
    254     let parser = DateTimeParser::new();
    255     for entry in fs::read_dir(dir)? {
    256         let repo = entry?;
    257         if repo.file_type()?.is_dir() {
    258             let path = repo.path().into_os_string().into_string()?;
    259             let output = Command::new(GIT)
    260                 .stderr(Stdio::piped())
    261                 .stdin(Stdio::null())
    262                 .stdout(Stdio::piped())
    263                 .args([
    264                     "-C",
    265                     path.as_str(),
    266                     "log",
    267                     "-1",
    268                     "--date=iso-strict",
    269                     "--pretty=format:%cd",
    270                 ])
    271                 .output()?;
    272             if output.status.success() {
    273                 let value = str::from_utf8(output.stdout.as_slice())?;
    274                 parser.parse_timestamp(value).map(|time| {
    275                     map.entry(time)
    276                         .or_insert_with(|| Vec::with_capacity(1))
    277                         .push(path);
    278                 })?;
    279             } else {
    280                 return Err(E::GitErr(output.stderr));
    281             }
    282         }
    283     }
    284     Ok(())
    285 }
    286 /// Writes each `String` in each `Vec` to `stdout` with spaces in between in descending order
    287 /// of `map`.
    288 fn write_results(map: BTreeMap<Timestamp, Vec<String>>) -> Result<(), Error> {
    289     let mut stdout = io::stdout().lock();
    290     map.into_values().rev().try_fold((), |(), paths| {
    291         paths
    292             .into_iter()
    293             .try_fold((), |(), path| write!(&mut stdout, "{path} "))
    294     })
    295 }
    296 /// The absolute path to `git`.
    297 const GIT: &str = "/usr/local/bin/git";
    298 fn main() -> Result<(), E> {
    299     let mut promises = pledge_init()?;
    300     veil_all()?;
    301     let git_dir = args::from_env_args()?;
    302     unveil_read(git_dir.as_ref())?;
    303     unveil_git()?;
    304     pledge_away_unveil(&mut promises)?;
    305     let mut map = BTreeMap::new();
    306     get_git_data(&mut map, git_dir)?;
    307     pledge_away_all_but_stdio(&mut promises)?;
    308     write_results(map).map_err(E::Io)
    309 }