Checkout: files added once are written from their text, new files written in parallel (refs #41) 091fef80755d

            // A file added once and never edited is its text: no graph.

            let single: Vec<Option<crate::objects::TextRef>> =

                nodes.iter().map(|n| target.single_text(n)).collect();

            let graphs: Vec<NodeId> = nodes

                .iter()

                .zip(&single)

                .filter(|(_, s)| s.is_none())

                .map(|(n, _)| *n)

                .collect();

            let mut texts = {

                let _t = crate::timing::phase("checkout: read single texts");

                let wanted: Vec<crate::objects::TextRef> =

                    single.iter().flatten().copied().collect();

                self.single_texts(&wanted)?.into_iter()

            };

                self.load_graphs_of(&mut target, &graphs)?;

                let mut out: Vec<Option<(Vec<u8>, bool)>> = single

                    .iter()

                    .map(|s| s.as_ref().and_then(|_| texts.next().map(|t| (t, false))))

                    .collect();

                let from_graphs: Vec<(Vec<u8>, bool)> = graphs

                    .collect();

                let mut from_graphs = from_graphs.into_iter();

                for o in out.iter_mut().filter(|o| o.is_none()) {

                    *o = from_graphs.next();

                }

                out.into_iter()

                    .map(|o| o.expect("every file rendered"))

            #[cfg(test)]

            {

                let singles: Vec<NodeId> = nodes

                    .iter()

                    .zip(&single)

                    .filter(|(_, s)| s.is_some())

                    .map(|(n, _)| *n)

                    .collect();

                self.load_graphs_of(&mut target, &singles)?;

                for (n, (bytes, _)) in nodes.iter().zip(&rendered) {

                    assert_eq!(

                        *bytes,

                        target.render_file(n).0,

                        "a single text is its file's rendering"

                    );

                }

            }

            let on_disk: Vec<Vec<u8>> = batch

                .iter()

                .zip(rendered.iter())

                .map(|((path, _, _), (bytes, _))| {

                    if attrs.lookup(path).eol == Some(crate::attributes::Eol::Crlf) {

                        crate::attributes::to_crlf(bytes)

                    } else {

                        bytes.clone()

                    }

                })

                .collect();

            // Each directory checked (no symlink on the way) and made once,

            // then the files compared and written on every core.

            let mut dirs: BTreeSet<&str> = BTreeSet::new();

            for (path, _, _) in batch {

                if let Some((dir, _)) = path.rsplit_once('/') {

                    dirs.insert(dir);

                }

            }

            for dir in dirs {

                let full = self.safe_path(dir)?;

                if !full.is_dir() {

                    if fs::symlink_metadata(&full).is_ok() {

                        remove_any(&full)?;

                    }

                    fs::create_dir_all(&full)?;

            }

            for (path, _, _) in batch {

                check_path_name(path)?;

            }

            let (root, exec_bits) = (&self.root, self.platform.exec_bits);

            // Compared on every core; new files written on every core too,

            // but files that exist rewritten one at a time: on ext4,

            // rewriting in parallel was six times slower (each truncation

            // starts writing back the old blocks).

            let plans: Vec<Disk> = batch

                .par_iter()

                .zip(on_disk.par_iter())

                .map(|((path, _, mode), bytes)| {

                    compare_on_disk(&root.join(path), bytes, mode.exec, exec_bits)

                })

                .collect();

            let fresh: Vec<usize> = (0..batch.len())

                .filter(|&i| plans[i] == Disk::Absent)

                .collect();

            fresh

                .par_iter()

                .map(|&i| write_file_at(&root.join(&batch[i].0), &on_disk[i], batch[i].2.exec))

                .collect::<std::io::Result<()>>()?;

            for (i, plan) in plans.iter().enumerate() {

                if *plan == Disk::Differs {

                    write_file_at(&root.join(&batch[i].0), &on_disk[i], batch[i].2.exec)?;

                }

            }

            report.written += plans.iter().filter(|p| **p != Disk::Same).count();

            for (((path, node, mode), (_, conflicted)), on_disk) in

                batch.iter().zip(rendered).zip(on_disk)

            {

                let a = attrs.lookup(path);

    }

}

/// Refuse a path that could escape the workspace (spec §7.7): an empty,

/// `.` or `..` component, a backslash, or a first component `.oxy`.

fn check_path_name(rel: &str) -> Result<()> {

    for (i, comp) in rel.split('/').enumerate() {

        if comp.is_empty() || comp == "." || comp == ".." || comp.contains('\\') {

            return fail(format!("refusing unsafe path {rel:?}"));

        }

        if i == 0 && comp == OXY_DIR {

            return fail(format!("refusing to write inside {OXY_DIR}: {rel:?}"));

        }

    }

    Ok(())

}

/// A file on disk against what a checkout would write there.

#[derive(Clone, Copy, PartialEq, Eq)]

enum Disk {

    Same,

    Differs,

    Absent,

}

/// Whether the file at `full` already holds `bytes` with the right

/// executable bit. Touches no repository state, so it runs in parallel.

fn compare_on_disk(full: &Path, bytes: &[u8], exec: bool, exec_bits: bool) -> Disk {

    match fs::symlink_metadata(full) {

        Ok(m)

            if m.is_file()

                && m.len() == bytes.len() as u64

                && (!exec_bits || is_executable(&m) == exec)

                && fs::read(full).is_ok_and(|b| b == bytes) =>

        {

            Disk::Same

        }

        Ok(_) => Disk::Differs,

        Err(_) => Disk::Absent,

    }

}

/// Write a file whose directory exists, replacing whatever is there.

fn write_file_at(full: &Path, bytes: &[u8], exec: bool) -> std::io::Result<()> {

    match fs::symlink_metadata(full) {

        Ok(m) if m.is_file() => {

            if m.permissions().readonly() {

                set_readonly(full, false)?;

            }

        }

        Ok(_) => remove_any(full)?,

        Err(_) => {}

    fs::write(full, bytes)?;

    set_executable(full, exec)

    /// The contents of texts [`State::single_text`] gave: blobs read in

    /// one go, inline ones from their changes.

    pub(crate) fn single_texts(&self, texts: &[crate::objects::TextRef]) -> Result<Vec<Vec<u8>>> {

        use crate::objects::TextRef;

        let refs: Vec<ObjectRef> = texts

            .iter()

            .filter_map(|t| match t {

                TextRef::Blob(r, _, _) => Some(*r),

                TextRef::Inline { .. } => None,

            })

            .collect();

        let mut blobs = self.read_blobs(&refs)?.into_iter();

        let mut out = Vec::with_capacity(texts.len());

        for t in texts {

            let lines = match t {

                TextRef::Blob(_, count, form) => {

                    let content = blobs

                        .next()

                        .ok_or_else(|| RepoError::Msg("text blobs: wrong count".into()))?;

                    crate::objects::text_lines(&content, *count, *form)?

                }

                TextRef::Inline { change, start, end } => {

                    let bytes = self.change_bytes(change)?;

                    let range = bytes.get(*start as usize..*end as usize).ok_or_else(|| {

                        RepoError::Msg("an inline insert lies outside its change".into())

                    })?;

                    crate::objects::inline_lines(range)?

                }

            };

            out.push(lines.bytes().to_vec());

        }

        Ok(out)

    }

            let needed = {

                let _t = crate::timing::phase("fetch: negotiate");

                remote.negotiate(&have, &r.heads)?

            };

            let bundle = {

                let _t = crate::timing::phase("fetch: bundle");

                remote.fetch(&needed, max_blob)?

            };

            let imported = {

                let _t = crate::timing::phase("fetch: import");

                self.import_bundle(&bundle, false)?

            };

    /// The one text a file's history is, when it is a single insert of

    /// the whole file into nothing (a file added once and never edited,

    /// with no checkpoint base): its rendering is that text, so it needs

    /// no graph. `None` otherwise, or when the graph is built.

    pub fn single_text(&self, node: &NodeId) -> Option<TextRef> {

        if self.files.contains_key(node) {

            return None;

        }

        let d = self.deferred.as_ref()?.get(node)?.body();

        let [(_, edits)] = d.edits.as_slice() else {

            return None;

        };

        let [Edit::Insert {

            after: AtomRef::Start,

            before: AtomRef::End,

            lines,

            ..

        }] = edits.as_slice()

        else {

            return None;

        };

        match (&d.base, d.texts.as_slice()) {

            (None, [t]) if lines.is_empty() => Some(*t),

            _ => None,

        }

    }