ggen-core 26.7.2

Core graph-aware code generation engine
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

//! Canonical hash computation
//!
//! Provides deterministic hash computation using SHA-256.
//! Same input always produces same hash.

use crate::canonical::{CanonicalError, Result};
use sha2::{Digest, Sha256};

/// Compute SHA-256 hash of bytes
///
/// # Errors
///
/// Returns error if input cannot be hashed (should never fail for valid bytes)
pub fn compute_hash<T: AsRef<[u8]>>(data: &T) -> Result<String> {
    let mut hasher = Sha256::new();
    hasher.update(data.as_ref());
    let result = hasher.finalize();
    Ok(hex::encode(result))
}

/// Compute hash of multiple inputs concatenated
///
/// # Errors
///
/// Returns error if inputs cannot be hashed
pub fn compute_hash_multi<T: AsRef<[u8]>>(data: &[T]) -> Result<String> {
    let mut hasher = Sha256::new();
    for item in data {
        hasher.update(item.as_ref());
    }
    let result = hasher.finalize();
    Ok(hex::encode(result))
}

/// Hash verifier for determinism testing
pub struct HashVerifier {
    expected: String,
}

impl HashVerifier {
    /// Create a new hash verifier
    pub fn new(expected: String) -> Self {
        Self { expected }
    }

    /// Verify that data matches expected hash
    ///
    /// # Errors
    ///
    /// Returns error if hash does not match or computation fails
    pub fn verify<T: AsRef<[u8]>>(&self, data: &T) -> Result<()> {
        let actual = compute_hash(data)?;
        if actual == self.expected {
            Ok(())
        } else {
            Err(CanonicalError::Hash(format!(
                "Hash mismatch: expected {}, got {}",
                self.expected, actual
            )))
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_deterministic_hash() {
        let data = b"test data";
        let hash1 = compute_hash(&data).unwrap();
        let hash2 = compute_hash(&data).unwrap();
        assert_eq!(hash1, hash2);
    }

    #[test]
    fn test_hash_length() {
        let data = b"test";
        let hash = compute_hash(&data).unwrap();
        assert_eq!(hash.len(), 64); // SHA-256 = 32 bytes = 64 hex chars
    }

    #[test]
    fn test_multi_hash_deterministic() {
        let data = vec![
            b"part1".as_slice(),
            b"part2".as_slice(),
            b"part3".as_slice(),
        ];
        let hash1 = compute_hash_multi(&data).unwrap();
        let hash2 = compute_hash_multi(&data).unwrap();
        assert_eq!(hash1, hash2);
    }

    #[test]
    fn test_hash_verifier_success() {
        let data = b"test data";
        let hash = compute_hash(&data).unwrap();
        let verifier = HashVerifier::new(hash);
        assert!(verifier.verify(&data).is_ok());
    }

    #[test]
    fn test_hash_verifier_failure() {
        let data1 = b"test data";
        let data2 = b"different data";
        let hash1 = compute_hash(&data1).unwrap();
        let verifier = HashVerifier::new(hash1);
        assert!(verifier.verify(&data2).is_err());
    }
}