heddle-objects 0.15.0

An AI-native version control system
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118

// SPDX-License-Identifier: Apache-2.0
//! Build canonical FileProvenance from a completed origin stream.

use crate::object::{ContentHash, FileProvenance, Origin, OriginSet};

use super::types::{BlameSliceError, OriginRange};

/// Assemble [`FileProvenance`] from finalized ranges without holding history.
///
/// Ranges are sorted, checked for exact coverage, and coalesced when adjacent
/// ranges share the same origin.
pub fn finalize_file_provenance(
    file_blob: ContentHash,
    line_count: u32,
    ranges: impl IntoIterator<Item = OriginRange>,
) -> Result<FileProvenance, BlameSliceError> {
    let mut ranges: Vec<OriginRange> = ranges.into_iter().collect();
    ranges.sort_by_key(|range| range.target_start);

    if line_count == 0 {
        if ranges
            .iter()
            .any(|range| range.target_start != 0 || range.len != 0)
        {
            return Err(BlameSliceError::InvalidCoverage);
        }
        let origins = ranges
            .first()
            .map(|range| vec![range.origin.clone()])
            .unwrap_or_default();
        let origin_sets = if origins.is_empty() {
            Vec::new()
        } else {
            vec![OriginSet {
                origin_indexes: vec![0],
            }]
        };
        let provenance = FileProvenance::new(file_blob, 0, Vec::new(), origins, origin_sets);
        provenance
            .validate()
            .map_err(|_| BlameSliceError::InvalidCoverage)?;
        return Ok(provenance);
    }

    let coalesced = coalesce(ranges);
    let mut next_line = 0u32;
    let mut origins: Vec<Origin> = Vec::new();
    let mut origin_sets = Vec::new();
    let mut spans = Vec::new();

    for range in coalesced {
        if range.target_start != next_line || range.len == 0 {
            return Err(BlameSliceError::InvalidCoverage);
        }
        let origin_index = origin_index(&mut origins, range.origin);
        let origin_set_index = origin_set_index(&mut origin_sets, origin_index);
        spans.push(crate::object::LineSpan {
            start_line: range.target_start,
            line_len: range.len,
            origin_set_index,
        });
        next_line = next_line.saturating_add(range.len);
    }
    if next_line != line_count {
        return Err(BlameSliceError::InvalidCoverage);
    }

    let provenance = FileProvenance::new(file_blob, line_count, spans, origins, origin_sets);
    provenance
        .validate()
        .map_err(|_| BlameSliceError::InvalidCoverage)?;
    Ok(provenance)
}

fn coalesce(ranges: Vec<OriginRange>) -> Vec<OriginRange> {
    let mut out: Vec<OriginRange> = Vec::new();
    for range in ranges {
        match out.last_mut() {
            Some(last)
                if last.target_start + last.len == range.target_start
                    && last.origin == range.origin =>
            {
                last.len += range.len;
            }
            _ => out.push(range),
        }
    }
    out
}

fn origin_index(origins: &mut Vec<Origin>, origin: Origin) -> u32 {
    if let Some((index, _)) = origins
        .iter()
        .enumerate()
        .find(|(_, existing)| **existing == origin)
    {
        return index as u32;
    }
    let next = origins.len() as u32;
    origins.push(origin);
    next
}

fn origin_set_index(origin_sets: &mut Vec<OriginSet>, origin_index: u32) -> u32 {
    let indexes = vec![origin_index];
    if let Some((index, _)) = origin_sets
        .iter()
        .enumerate()
        .find(|(_, set)| set.origin_indexes == indexes)
    {
        return index as u32;
    }
    let next = origin_sets.len() as u32;
    origin_sets.push(OriginSet {
        origin_indexes: indexes,
    });
    next
}