Coverage / crates/hub/src/repos/proposals.rs 90.2%

pub fn project(repo: &Repo, cache: &StateCache, target: &str, source: Source<'_>) -> Result<Projection> {

    let target_heads = repo.bookmarks()?.into_iter().find(|b| b.name == target).map(|b| b.heads).unwrap_or_default();

    let candidate: Vec<ChangeHash> = match &source {

        Source::Bookmark(heads) => heads.clone(),

        Source::Changes(hashes) => hashes.clone(),

        Source::Fork { fork, heads } => {

            let fork_state = fork.load_state(heads)?;

            let missing: Vec<ChangeHash> = fork_state.changes().map(|(h, _)| *h).filter(|h| !repo.store().has(h)).collect();

            if !missing.is_empty() {

                let bundle = fork.bundle_for(&missing)?;

                repo.import_bundle(&bundle, repo.current_policy()?.is_some())?;

            }

            heads.clone()

    for h in &candidate {

        if !repo.store().has(h) {

        }

    let mut union: Vec<ChangeHash> = target_heads.clone();

    union.extend(candidate.iter().copied());

    let loaded = cache.load(repo, &union)?;

    let heads = loaded.state.heads();

    let target_loaded = cache.load(repo, &target_heads)?;

    let labels = view::head_labels(repo)?;

    let head_set: BTreeSet<ChangeHash> = heads.iter().copied().collect();

    let mut added: Vec<(ChangeHash, oxy_core::state::ChangeMeta)> =

        loaded.state.changes().filter(|(h, _)| !target_loaded.state.contains(h)).map(|(h, m)| (*h, m.clone())).collect();

    added.sort_by(|a, b| a.1.hlc.cmp(&b.1.hlc).then(a.0.cmp(&b.0)));

    let hashes: Vec<ChangeHash> = added.iter().map(|(h, _)| *h).collect();

    let changes: Vec<ChangeView> = added.iter().map(|(h, m)| view::change_view_pub(repo, h, m, head_set.contains(h), &labels)).collect();

    let conflicted = loaded.snapshot.is_conflicted();

    let conflicts = if conflicted { view::conflicts_in(repo, &loaded, "projected") } else { vec![] };

    let (files, bases) = crate::render::diff::snapshot_diff(&target_loaded.snapshot, &loaded.snapshot);

    let state = StateObject::new(heads.clone()).hash();

    let target_state = StateObject::new(target_heads.clone()).hash();

    Ok(Projection { target_heads, target_state, heads, state, changes, hashes, conflicted, conflicts, files, bases, loaded })

}

pub fn atom_at(loaded: &Loaded, path: &str, new_no: usize) -> Option<(ChangeHash, u32)> {

    let f = loaded.snapshot.files.get(path)?;

    if !matches!(f.content, FileContent::Text { .. }) {

    }

    let lines = loaded.state.live_lines(&f.node);

    lines.get(new_no.checked_sub(1)?).map(|((h, i), _)| (*h, *i))

}

pub fn atoms_of(loaded: &Loaded, path: &str) -> Option<Vec<(ChangeHash, u32)>> {

    let f = loaded.snapshot.files.get(path)?;

    if !matches!(f.content, FileContent::Text { .. }) {

    }

    Some(loaded.state.live_lines(&f.node).iter().map(|((h, i), _)| (*h, *i)).collect())

}

pub fn sealing_keys(repo: &Repo, hashes: &[ChangeHash]) -> Result<Vec<KeyId>> {

    if hashes.is_empty() {

        return Ok(vec![]);

    }

    let mut counts: HashMap<KeyId, usize> = HashMap::new();

    for h in hashes {

        let mut keys_here: BTreeSet<KeyId> = BTreeSet::new();

        for seal_ref in repo.store().seals_for(h)? {

            let attest = repo.store().get_attest(&seal_ref)?;

            let oxy_core::attest::AttestBody::Seal { hashes: covered } = &attest.body else { continue };

            if !covered.contains(h) {

            }

            for sig in repo.store().signatures(&seal_ref)? {

                if let Ok(id) = repo.store().get_identity(&sig.key) {

                    if oxy_core::identity::verify(&id, &sig, oxy_core::identity::Domain::Attest, &seal_ref).is_ok() {

                        keys_here.insert(sig.key);

                    }

        for k in keys_here {

            *counts.entry(k).or_default() += 1;

        }

    Ok(counts.into_iter().filter(|(_, n)| *n == hashes.len()).map(|(k, _)| k).collect())

}

pub fn owners_for(target: &Loaded, touched: &[String]) -> Vec<String> {

    let Some(f) = target.snapshot.files.get(".oxyowners") else { return vec![] };

    let FileContent::Text { bytes, .. } = &f.content else { return vec![] };

    let text = String::from_utf8_lossy(bytes);

    let rules: Vec<(String, Vec<String>)> = text

        .lines()

        .map(str::trim)

        .filter(|l| !l.is_empty() && !l.starts_with('#'))

        .filter_map(|l| {

            let mut parts = l.split_whitespace();

            let pattern = parts.next()?.to_string();

            let owners: Vec<String> = parts.map(|o| o.trim_start_matches('@').to_string()).collect();

            Some((pattern, owners))

        })

        .collect();

    let mut out: BTreeSet<String> = BTreeSet::new();

    for path in touched {

        if let Some((_, owners)) = rules.iter().rev().find(|(pattern, _)| owner_pattern_matches(pattern, path)) {

            out.extend(owners.iter().cloned());

        }

    out.into_iter().collect()

}

fn owner_pattern_matches(pattern: &str, path: &str) -> bool {

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

    if p == "*" {

        return true;

    }

    if let Some(dir) = p.strip_suffix('/') {

        return path.starts_with(&format!("{dir}/"));

    }

    if let Some(ext) = p.strip_prefix("*.") {

        return path.ends_with(&format!(".{ext}"));

    }

    if let Some(prefix) = p.strip_suffix("/*") {

        return path.strip_prefix(&format!("{prefix}/")).is_some_and(|rest| !rest.contains('/'));

    }

    if let Some(prefix) = p.strip_suffix("/**") {

        return path.starts_with(&format!("{prefix}/"));

    }

    path == p || path.starts_with(&format!("{p}/"))

}

pub fn state_ref(heads: &[ChangeHash]) -> ObjectRef {

    StateObject::new(heads.to_vec()).hash()

}

    fn owner_patterns() {

        assert!(owner_pattern_matches("*", "any/thing"));

        assert!(owner_pattern_matches("docs/", "docs/spec.md"));

        assert!(!owner_pattern_matches("docs/", "src/docs.rs"));

        assert!(owner_pattern_matches("*.rs", "src/main.rs"));

        assert!(owner_pattern_matches("src/*", "src/main.rs"));

        assert!(!owner_pattern_matches("src/*", "src/a/b.rs"));

        assert!(owner_pattern_matches("crates/**", "crates/hub/src/lib.rs"));

        assert!(owner_pattern_matches("Cargo.toml", "Cargo.toml"));

    }