Windows paths print plainly (closes #143) 544d0541a7e5

## Unreleased

- **Oxygen's CI writes a test report beside its coverage (#139):** the test job runs under cargo-nextest (`.config/nextest.toml`, profile `ci`) as well as cargo-llvm-cov, keeping a JUnit report whether or not the tests pass, for the hub's Tests tab.

- **Pushing a new bookmark sends only what the remote lacks (#142).** A push was worked out against the remote's heads for that bookmark alone, so a bookmark new to the remote sent its whole history again: slow on a big repository, and OxygenHub's push protection scanned all of it (and refused a proposal's bookmark for an example key in a change main had had for weeks). The heads of every bookmark the remote lists now count as already there.

- **A binary file's or subrepo pin's conflict can be settled from the command line (#140).** Two changes that replaced the same binary file, or moved the same subrepo pin, leave a replace conflict with no markers to edit, and every commit was refused until it was settled, which only a hosted edit could do. `oxy resolve PATH…` now settles it with what the working copy holds at the path (the file, or the subrepo's pin): the next commit is a resolution replacing every version with it. A path with no replace conflict is refused, and a choice is forgotten once committed.

    out

}

/// Why Windows would refuse a path, if it would.

pub fn windows_name_problem(path: &str) -> Option<&'static str> {

    const RESERVED: &[&str] = &[

#[cfg(test)]

mod tests {

    use super::*;

    #[test]

    fn collisions_and_names() {

impl Repo {

    fn git_marks_dir(&self, git_dir: &Path) -> Result<PathBuf> {

        let key = hash_object(ObjectType::Chunk, canonical.to_string_lossy().as_bytes()).short(16);

        let dir = self.oxy.join("git").join(key);

        fs::create_dir_all(&dir)?;

    /// new changes join the bookmark like a pull.

    pub fn git_fetch(&self, url: &str, branch: &str) -> Result<GitImportReport> {

        // A local path, made absolute: git runs it from inside the mirror.

            .ok()

            .filter(|_| !url.contains("://"));

        let absolute = local.as_ref().map(|p| p.to_string_lossy().into_owned());

    /// on the store at `storage` (`storage.url`), or in `.oxy/objects`.

    pub fn init_on(root: &Path, id: [u8; 16], storage: Option<&str>) -> Result<Repo> {

        fs::create_dir_all(root)?;

        let oxy = root.join(OXY_DIR);

        if oxy.exists() {

            return fail(format!("{} is already an oxy repository", root.display()));

    /// [`Repo::init_on`] for a bare repository.

    pub fn init_bare_on(root: &Path, id: [u8; 16], storage: Option<&str>) -> Result<Repo> {

        fs::create_dir_all(root)?;

        let oxy = root.join(OXY_DIR);

        if oxy.exists() {

            return fail(format!("{} is already an oxy repository", root.display()));

    /// Open the repository containing `start` (searching upwards).

    pub fn open(start: &Path) -> Result<Repo> {

        let mut dir: Option<&Path> = Some(&start);

        while let Some(d) = dir {

            let oxy = d.join(OXY_DIR);

            return fail(format!("{} exists and is not empty", dir.display()));

        }

        fs::create_dir_all(dir)?;

        if dir == self.root || dir.starts_with(&self.root) || self.root.starts_with(&dir) {

            return fail("a workspace cannot be inside another workspace of the same repository");

        }

        return None;

    }

    static STORES: OnceLock<Mutex<HashMap<PathBuf, Arc<MemoryStore>>>> = OnceLock::new();

    let mut map = STORES

        .get_or_init(Default::default)

        .lock()

    tls: Option<(PathBuf, PathBuf)>,

) -> Result<i32> {

    let listener = std::net::TcpListener::bind(bind).with_context(|| format!("binding {bind}"))?;

    let tls = tls.map(|(cert, key)| oxy_server::TlsFiles { cert, key });

    println!(

        "Serving repositories under {} on {}://{bind}/<repo>/oxy/v1/ ({})",