oxy gc says what it is doing 9ae4d15a0e4b

    /// Prune unreachable objects older than the grace period (`now`

    /// ignores it), then repack everything into one pack (spec §13.4).

    pub fn gc(&self, now: bool) -> Result<GcReport> {

        let keep = self.reachable()?;

        let grace = if now {

            std::time::Duration::ZERO

        } else {

            std::time::Duration::from_secs(self.config.gc_grace_days * 86_400)

        };

        // Then everything left in one pack, compressed harder than a

        // commit's (spec §13.4), as `git gc` repacks.

        Ok(GcReport {

            packed,

            pruned,

    assert!(!c.snapshot("status").unwrap().changed);

}

#[test]

fn gc_packs_objects_and_history_still_works() {

    hermetic();

    let dir = tempfile::tempdir().unwrap();

/// An object read from the store: its type and body.

pub type Object = (ObjectType, Vec<u8>);

#[derive(Clone, Copy, Debug)]

struct PackEntry {

    offset: u64,

            &loose.iter().map(|(_, p)| p.clone()).collect::<Vec<_>>(),

            &[],

            ZSTD_LEVEL,

        )

    }

    /// `level` (spec §13.4): what an explicit `oxy gc` does, as `git gc`

    /// repacks. Returns the report and how many packs were folded in.

    pub fn repack_all(&self, level: i32) -> Result<(PackReport, usize)> {

        let loose = self.loose_objects()?;

        let (mut refs, paths): (Vec<ObjectRef>, Vec<PathBuf>) = {

            let packs = self.packs.borrow();

        refs.extend(loose.iter().map(|(r, _)| *r));

        let loose_paths: Vec<PathBuf> = loose.into_iter().map(|(_, p)| p).collect();

        let n = paths.len();

        Ok((report, n))

    }

            )

        };

        let n = paths.len();

        Ok(n)

    }

    /// are rewritten without them. Signature sidecars and seal-index entries

    /// of deleted objects go too.

    pub fn prune(

        &self,

        keep: &std::collections::HashSet<ObjectRef>,

        grace: std::time::Duration,

    ) -> Result<PruneReport> {

        let now = std::time::SystemTime::now();

        let old_enough = |m: &fs::Metadata| {

            m.modified()

        let mut keep_refs: Vec<ObjectRef> = Vec::new();

        let mut old_paths: Vec<PathBuf> = Vec::new();

        let mut rewrite = false;

        for p in self.packs.borrow().iter() {

            let meta = fs::metadata(&p.path)?;

            let unreachable = p.refs.iter().filter(|r| !keep.contains(r)).count();

                    .filter(|r| !keep.contains(r))

                    .collect()

            };

            for r in dropped {

                self.remove_sidecars(&r)?;

            }

        loose_paths: &[PathBuf],

        old_packs: &[PathBuf],

        level: i32,

    ) -> Result<PackReport> {

        if refs.is_empty() {

            for p in old_packs {

        // A full repack of enough objects trains a dictionary for them.

        let dict = if level == REPACK_ZSTD_LEVEL && refs.len() >= DICT_MIN_OBJECTS {

            let _t = crate::timing::phase("pack: train a dictionary");

            self.train_dictionary(&refs)

        } else {

            None

            // compress it on every core, write it in order.

            let mut batches = refs.chunks(1024);

            let mut compressed_batch = Vec::new();

            loop {

                if compressed_batch.is_empty() {

                    let Some(batch) = batches.next() else { break };

                    let mut read: Vec<(ObjectRef, ObjectType, Vec<u8>, bool)> =

                        Vec::with_capacity(batch.len());

                    for r in batch {

        if let Some(d) = &dict {

            crate::durable::write_atomic(&self.dir.join(format!("pack-{id}.dict")), d)?;

        }

        self.finish_pack_files(&id, &tmp_pack, &index)?;

        for p in old_packs {

            remove_pack_files(p)?;

            None => println!("{msg}"),

        }

    }

    /// Clear the spinner without printing.

    pub fn clear(self) {

        if let Some(b) = &self.bar {

pub fn gc(now: bool) -> Result<i32> {

    let repo = open()?;

    let sp = ui::spinner("Packing and pruning…");

    sp.clear();

    if r.packed.objects > 0 {

        println!(