.oxyattributes: binary, text, eol=lf|crlf, nocompress (raw chunks in packs), lockable with advisory local oxy lock/unlock (spec 0.6j) cdb5beba7f05

//! `.oxyattributes` (spec §19): per-path attributes in gitattributes syntax.

//! Each line is `pattern attr...` where an attribute is `binary`, `text`

//! (or `-binary`), `eol=lf`, `eol=crlf`, `nocompress`, or `lockable`. A

//! pattern without a slash matches a basename anywhere below the file's

//! directory; one with a slash is anchored to that directory. Later rules

//! override earlier ones per attribute.

use globset::{Glob, GlobMatcher};

use std::collections::BTreeMap;

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

pub enum Eol {

    Lf,

    Crlf,

}

/// The attributes in force for one path.

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

pub struct Attrs {

    /// `Some(true)` forces opaque, `Some(false)` forces text (absent NUL bytes).

    pub binary: Option<bool>,

    pub eol: Option<Eol>,

    pub nocompress: bool,

    pub lockable: bool,

}

struct Rule {

    matcher: GlobMatcher,

    attrs: Vec<(String, Option<String>)>,

}

#[derive(Default)]

pub struct Attributes {

    rules: Vec<Rule>,

}

impl Attributes {

    /// Add the rules of one `.oxyattributes` file living in `dir` (`""` for the root).

    pub fn add_file(&mut self, dir: &str, text: &str) {

        for line in text.lines() {

            let line = line.trim();

            if line.is_empty() || line.starts_with('#') {

                continue;

            }

            let mut parts = line.split_whitespace();

            let Some(pattern) = parts.next() else { continue };

            let attrs: Vec<(String, Option<String>)> = parts

                .map(|a| match a.split_once('=') {

                    Some((k, v)) => (k.to_string(), Some(v.to_string())),

                    None => (a.to_string(), None),

                })

                .collect();

            let anchored = pattern.contains('/');

            let core = pattern.trim_start_matches('/');

            let full = match (dir.is_empty(), anchored) {

                (true, true) => core.to_string(),

                (true, false) => format!("**/{core}"),

                (false, true) => format!("{dir}/{core}"),

                (false, false) => format!("{dir}/**/{core}"),

            };

            if let Ok(g) = Glob::new(&full) {

                self.rules.push(Rule { matcher: g.compile_matcher(), attrs });

            }

        }

    }

    /// Build from every `.oxyattributes` in `files` (path → content).

    pub fn from_files<'a>(files: impl IntoIterator<Item = (&'a str, &'a [u8])>) -> Attributes {

        let mut sorted: BTreeMap<&str, &[u8]> = BTreeMap::new();

        for (p, c) in files {

            if p == ".oxyattributes" || p.ends_with("/.oxyattributes") {

                sorted.insert(p, c);

            }

        }

        let mut out = Attributes::default();

        // Shallower files first so deeper ones override.

        let mut entries: Vec<(&str, &[u8])> = sorted.into_iter().collect();

        entries.sort_by_key(|(p, _)| p.matches('/').count());

        for (p, c) in entries {

            let dir = p.strip_suffix(".oxyattributes").unwrap_or("").trim_end_matches('/');

            out.add_file(dir, &String::from_utf8_lossy(c));

        }

        out

    }

    pub fn lookup(&self, path: &str) -> Attrs {

        let mut a = Attrs::default();

        for r in &self.rules {

            if !r.matcher.is_match(path) {

                continue;

            }

            for (k, v) in &r.attrs {

                match (k.as_str(), v.as_deref()) {

                    ("binary", None) => a.binary = Some(true),

                    ("-binary", None) | ("text", None) => a.binary = Some(false),

                    ("eol", Some("lf")) => a.eol = Some(Eol::Lf),

                    ("eol", Some("crlf")) => a.eol = Some(Eol::Crlf),

                    ("-eol", None) => a.eol = None,

                    ("nocompress", None) => a.nocompress = true,

                    ("-nocompress", None) => a.nocompress = false,

                    ("lockable", None) => a.lockable = true,

                    ("-lockable", None) => a.lockable = false,

                    _ => {}

                }

            }

        }

        a

    }

    pub fn is_empty(&self) -> bool {

        self.rules.is_empty()

    }

}

/// `\r\n` → `\n`, as stored for `eol=` files.

pub fn normalize_eol(bytes: &[u8]) -> Vec<u8> {

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

    let mut i = 0;

    while i < bytes.len() {

        if bytes[i] == b'\r' && bytes.get(i + 1) == Some(&b'\n') {

            i += 1;

            continue;

        }

        out.push(bytes[i]);

        i += 1;

    }

    out

}

/// `\n` → `\r\n` (lines already ending in `\r\n` are left alone).

pub fn to_crlf(bytes: &[u8]) -> Vec<u8> {

    let mut out = Vec::with_capacity(bytes.len() + bytes.len() / 16);

    let mut prev = 0u8;

    for &b in bytes {

        if b == b'\n' && prev != b'\r' {

            out.push(b'\r');

        }

        out.push(b);

        prev = b;

    }

    out

}

#[cfg(test)]

mod tests {

    use super::*;

    #[test]

    fn parsing_and_precedence() {

        let a = Attributes::from_files([

            (".oxyattributes", &b"*.png binary nocompress\n*.txt eol=lf\ndocs/*.txt eol=crlf\nmodels/** lockable\n"[..]),

            ("src/.oxyattributes", &b"*.dat binary\ngen.txt -eol\n"[..]),

            ("README.md", &b"not attributes"[..]),

        ]);

        assert_eq!(a.lookup("a/b/logo.png"), Attrs { binary: Some(true), eol: None, nocompress: true, lockable: false });

        assert_eq!(a.lookup("notes.txt").eol, Some(Eol::Lf));

        assert_eq!(a.lookup("docs/notes.txt").eol, Some(Eol::Crlf));

        assert!(a.lookup("models/x/y.bin").lockable);

        assert_eq!(a.lookup("src/deep/x.dat").binary, Some(true));

        assert_eq!(a.lookup("other/x.dat").binary, None);

        assert_eq!(a.lookup("src/gen.txt").eol, None, "deeper file overrides");

        assert_eq!(a.lookup("src/other.txt").eol, Some(Eol::Lf));

        assert_eq!(a.lookup("plain"), Attrs::default());

    }

    #[test]

    fn eol_conversions() {

        assert_eq!(normalize_eol(b"a\r\nb\nc\r\n"), b"a\nb\nc\n");

        assert_eq!(to_crlf(b"a\nb\r\nc\n"), b"a\r\nb\r\nc\r\n");

        assert_eq!(normalize_eol(&to_crlf(b"x\ny\n")), b"x\ny\n");

    }

}

 "globset",

globset = "0.4"

pub mod attributes;

        let attrs = Repo::state_attributes(&target);

                    let a = attrs.lookup(path);

                    let on_disk: std::borrow::Cow<[u8]> = if a.eol == Some(crate::attributes::Eol::Crlf) { crate::attributes::to_crlf(bytes).into() } else { bytes.as_slice().into() };

                    let same = current.get(path).is_some_and(|c| c.kind == NodeKind::File && c.content == *on_disk && c.exec == f.mode.exec);

                        self.write_file(path, &on_disk, f.mode.exec)?;

                    if a.lockable && !self.is_locked(path) {

                        let _ = set_readonly(&self.root.join(path), true);

                    }

                        if attrs.lookup(path).lockable && !self.is_locked(path) {

                            let _ = set_readonly(&self.root.join(path), true);

                        }

        if fs::metadata(&full).is_ok_and(|m| m.permissions().readonly()) {

            set_readonly(&full, false)?;

        }

    /// Attributes from the `.oxyattributes` files in the working directory.

    pub fn disk_attributes(&self) -> crate::attributes::Attributes {

        let mut files: Vec<(String, Vec<u8>)> = Vec::new();

        if let Ok(b) = fs::read(self.root.join(".oxyattributes")) {

            files.push((".oxyattributes".into(), b));

        }

        let mut wb = ignore::WalkBuilder::new(&self.root);

        wb.hidden(false).git_ignore(false).git_global(false).git_exclude(false).require_git(false).follow_links(false).add_custom_ignore_filename(".oxyignore");

        wb.filter_entry(|e| e.file_name() != OXY_DIR);

        for entry in wb.build().flatten() {

            if entry.file_name() == ".oxyattributes" && entry.path() != self.root.join(".oxyattributes") {

                if let Ok(b) = fs::read(entry.path()) {

                    let rel: String = entry.path().strip_prefix(&self.root).unwrap().components().map(|c| c.as_os_str().to_string_lossy().to_string()).collect::<Vec<_>>().join("/");

                    files.push((rel, b));

                }

            }

        }

        crate::attributes::Attributes::from_files(files.iter().map(|(p, c)| (p.as_str(), c.as_slice())))

    }

    /// Attributes from a materialized state's `.oxyattributes` files.

    pub fn state_attributes(snapshot: &Snapshot) -> crate::attributes::Attributes {

        crate::attributes::Attributes::from_files(snapshot.files.iter().filter_map(|(p, f)| match &f.content {

            FileContent::Text { bytes, .. } if p == ".oxyattributes" || p.ends_with("/.oxyattributes") => Some((p.as_str(), bytes.as_slice())),

            _ => None,

        }))

    }

    /// Store a blob, raw when the path is `nocompress`.

    pub fn store_blob_for(&self, content: &[u8], nocompress: bool) -> Result<ObjectRef> {

        if !nocompress {

            return self.store_blob(content);

        }

        for c in crate::chunk::chunks(content) {

            self.store.put_chunk_nocompress(c)?;

        }

        Ok(self.store.put(ObjectType::Blob, &Self::blob_for(content).encode())?)

    }

    fn locks_dir(&self) -> PathBuf {

        self.oxy.join("locks")

    }

    /// Whether `path` is locked locally for editing (spec §18, advisory).

    pub fn is_locked(&self, path: &str) -> bool {

        self.locks_dir().join(path.replace('/', "%2F")).exists()

    }

    /// Take the advisory local lock on a `lockable` file and make it writable.

    pub fn lock_path(&self, path: &str) -> Result<()> {

        let attrs = self.disk_attributes();

        if !attrs.lookup(path).lockable {

            return fail(format!("{path} is not marked lockable in .oxyattributes"));

        }

        fs::create_dir_all(self.locks_dir())?;

        write_atomic(&self.locks_dir().join(path.replace('/', "%2F")), std::process::id().to_string().as_bytes())?;

        set_readonly(&self.root.join(path), false)?;

        Ok(())

    }

    /// Release the local lock and make the file read-only again.

    pub fn unlock_path(&self, path: &str) -> Result<()> {

        let _ = fs::remove_file(self.locks_dir().join(path.replace('/', "%2F")));

        if self.root.join(path).exists() {

            set_readonly(&self.root.join(path), true)?;

        }

        Ok(())

    }

fn set_readonly(path: &Path, readonly: bool) -> std::io::Result<()> {

    let mut perms = fs::metadata(path)?.permissions();

    perms.set_readonly(readonly);

    fs::set_permissions(path, perms)

}

        // Attributes come from the files being committed, so a new

        // `.oxyattributes` applies to the same change that adds it.

        let attrs = crate::attributes::Attributes::from_files(

            fs_entries.iter().filter(|(p, _)| p.as_str() == ".oxyattributes" || p.ends_with("/.oxyattributes")).map(|(p, e)| (p.as_str(), e.content.as_slice())),

        );

        let mut b = ChangeBuilder::new(base, base_snapshot, reuse).with_attributes(attrs);

    attrs: crate::attributes::Attributes,

        ChangeBuilder { base, base_snapshot, tree_ops: vec![], edits: vec![], statuses: vec![], dir_nodes, reuse, contributors: BTreeSet::new(), resolves: false, attrs: crate::attributes::Attributes::default() }

    fn with_attributes(mut self, attrs: crate::attributes::Attributes) -> Self {

        self.attrs = attrs;

        self

    }

    /// Whether a file is opaque: forced by `binary`, forced text by `text`

    /// only when it has no NUL bytes, else sniffed.

    fn opaque_for(&self, path: &str, e: &FsEntry) -> bool {

        if e.kind == NodeKind::Symlink {

            return true;

        }

        match self.attrs.lookup(path).binary {

            Some(true) => true,

            Some(false) => is_binary(&e.content),

            None => is_binary(&e.content),

        }

    }

    /// Text content as stored: `\r\n` normalized for `eol=` files.

    fn stored_text(&self, path: &str, content: &[u8]) -> Vec<u8> {

        if self.attrs.lookup(path).eol.is_some() { crate::attributes::normalize_eol(content) } else { content.to_vec() }

    }

        let opaque = self.opaque_for(path, e);

        let nocompress = self.attrs.lookup(path).nocompress;

            let blob = repo.store_blob_for(&e.content, nocompress)?;

            let content = self.stored_text(path, &e.content);

                lines: split_lines(&content).iter().map(|l| l.to_vec()).collect(),

        let wants_opaque = self.opaque_for(path, e);

        let nocompress = self.attrs.lookup(path).nocompress;

        let disk_text = self.stored_text(path, &e.content);

                    if bytes == &disk_text {

                    let mut edits = text_edits(node, &regions.plain, &disk_text);

                if wants_opaque {

                    // Text → opaque (spec §7.5), by content or by attribute.

                    if let Some(old) = mode_atom {

                        self.tree_ops.push(TreeOp::SetMode { node, old, mode: Mode { exec: e.exec, opaque: true } });

                    }

                    let live: Vec<_> = repo_live_keys(self.base, &node);

                    if !live.is_empty() {

                        self.edits.push(Edit::Delete { node, atoms: ranges(&live) });

                    }

                    let blob = repo.store_blob_for(&e.content, nocompress)?;

                    self.edits.push(Edit::Replace { node, old: None, new: Some(blob) });

                    status = Some(ChangeStatus::Modified);

                } else if bytes != &disk_text {

                    let old = self.base.live_lines(&node);

                    let edits = text_edits(node, &old, &disk_text);

                    if !edits.is_empty() {

                        self.edits.extend(edits);

                let switched_to_opaque = wants_opaque;

                    if e.kind == NodeKind::File && !wants_opaque {

                        let blob = repo.store_blob_for(&e.content, nocompress)?;

#[test]

fn attributes_binary_eol_nocompress_lockable() {

    hermetic();

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

    let root = dir.path();

    let repo = Repo::init(root).unwrap().with_home(root.join("home"));

    write(root, ".oxyattributes", b"*.dat binary nocompress\n*.txt eol=crlf\nassets/** lockable\n");

    write(root, "plain.dat", b"no nul bytes here\n");

    write(root, "notes.txt", b"one\r\ntwo\r\n");

    write(root, "assets/model.bin", b"\0model");

    let h = repo.commit("attrs", &[]).unwrap();

    let snap = repo.load_state(&[h]).unwrap().materialize();

    assert!(snap.files["plain.dat"].mode.opaque, "binary attribute forces opaque without NUL bytes");

    assert!(matches!(&snap.files["notes.txt"].content, FileContent::Text { bytes, .. } if bytes == b"one\ntwo\n"), "stored with LF");

    assert!(!repo.snapshot("status").unwrap().changed, "CRLF on disk equals LF in the state");

    // nocompress chunks pack raw.

    let r = repo.gc(true).unwrap();

    assert!(r.packed.objects > 0);

    // Checkout writes CRLF for eol=crlf and makes lockable files read-only.

    fs::remove_file(root.join("notes.txt")).unwrap();

    repo.checkout(&[h], true, "co").unwrap();

    assert_eq!(fs::read(root.join("notes.txt")).unwrap(), b"one\r\ntwo\r\n");

    assert!(fs::metadata(root.join("assets/model.bin")).unwrap().permissions().readonly());

    assert!(repo.lock_path("plain.dat").is_err(), "not lockable");

    repo.lock_path("assets/model.bin").unwrap();

    assert!(!fs::metadata(root.join("assets/model.bin")).unwrap().permissions().readonly());

    assert!(repo.is_locked("assets/model.bin"));

    write(root, "assets/model.bin", b"\0model2");

    repo.commit("edit model", &[]).unwrap();

    repo.unlock_path("assets/model.bin").unwrap();

    assert!(fs::metadata(root.join("assets/model.bin")).unwrap().permissions().readonly());

    // A later checkout can still overwrite a read-only lockable file.

    repo.checkout(&[h], true, "co").unwrap();

    assert_eq!(fs::read(root.join("assets/model.bin")).unwrap(), b"\0model");

}

                let (flags, stored) = if self.is_nocompress(r) {

                    (0, body.clone())

                } else {

                    let compressed = zstd::bulk::compress(&body, ZSTD_LEVEL).map_err(|e| StoreError::Corrupt(*r, format!("zstd: {e}")))?;

                    if compressed.len() < body.len() { (FLAG_ZSTD, compressed) } else { (0, body.clone()) }

                };

    /// Store a chunk that packs will keep uncompressed (`nocompress`, spec §13.3).

    pub fn put_chunk_nocompress(&self, bytes: &[u8]) -> Result<ObjectRef> {

        let r = self.put(ObjectType::Chunk, bytes)?;

        let dir = self.dir.join("nocompress");

        fs::create_dir_all(&dir)?;

        let _ = fs::File::create(dir.join(r.to_hex()));

        Ok(r)

    }

    fn is_nocompress(&self, r: &ObjectRef) -> bool {

        self.dir.join("nocompress").join(r.to_hex()).exists()

    }

    fn nocompress_chunks_pack_raw() {

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

        let s = Store::open(dir.path()).unwrap();

        let body = vec![b'a'; 10_000];

        let raw = s.put_chunk_nocompress(&body).unwrap();

        let compressible = s.put(ObjectType::Chunk, &vec![b'b'; 10_000]).unwrap();

        s.pack_loose().unwrap();

        let packs = s.packs.borrow();

        let (i, e) = s.find_packed(&raw).unwrap();

        assert_eq!((e.flags, e.stored_len as usize), (0, 10_000));

        let (_, c) = s.find_packed(&compressible).unwrap();

        assert_eq!(c.flags, FLAG_ZSTD);

        assert!(c.stored_len < 10_000);

        assert_eq!(packs[i].read(&raw, e).unwrap().1, body);

    }

    #[test]

| **Status** | Draft 0.6j |

| `.oxyattributes` | Per-path attributes: `binary` (force opaque), `text` (text unless NUL bytes), `eol=lf|crlf` (store LF; check out as given), `nocompress` (chunks packed raw), `lockable` (read-only until `oxy lock`), `filter=<name>`. Gitattributes syntax: a pattern without `/` matches basenames below the file's directory, one with `/` is anchored to it; later rules and deeper files override. The attributes in force for a change are those in the files being committed. |

*Changelog.* Draft 0.6j (2026-09-27): `.oxyattributes` semantics (§19).

Draft 0.6i (2026-09-27): secondary workspaces and their `.oxy` file (§12.2).

    /// Take the advisory local lock on a lockable file, making it writable

    Lock { path: String },

    /// Release the local lock and make the file read-only again

    Unlock { path: String },

        Cmd::Lock { path } => workspace::lock(&path),

        Cmd::Unlock { path } => workspace::unlock(&path),

pub fn lock(path: &str) -> Result<i32> {

    let repo = open()?;

    repo.lock_path(path)?;

    println!("{} {} (advisory, local)", ui::ok("Locked"), ui::path(path));

    Ok(0)

}

pub fn unlock(path: &str) -> Result<i32> {

    let repo = open()?;

    repo.unlock_path(path)?;

    println!("{} {}", ui::ok("Unlocked"), ui::path(path));

    Ok(0)

}