arete-hash 0.2.1

Authoritative typed artifact identity protocol for Arete
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

use thiserror::Error;

#[derive(Debug, Error)]
pub enum HashError {
    #[error("invalid hash identifier: {0}")]
    InvalidHashId(&'static str),
    #[error("unknown hash protocol version '{0}'")]
    UnknownVersion(String),
    #[error("unknown hash kind '{0}'")]
    UnknownKind(String),
    #[error("expected hash kind '{expected}', got '{actual}'")]
    UnexpectedKind { expected: String, actual: String },
    #[error("unknown hash algorithm '{0}'")]
    UnknownAlgorithm(String),
    #[error("hash kind '{kind}' requires profile '{expected}', not '{actual}'")]
    ProfileMismatch {
        kind: String,
        expected: String,
        actual: String,
    },
    #[error("invalid JSON: {0}")]
    InvalidJson(String),
    #[error("duplicate JSON object key '{0}'")]
    DuplicateJsonKey(String),
    #[error("unsafe JSON integer '{0}'")]
    UnsafeJsonInteger(String),
    #[error("non-finite JSON numbers are not supported")]
    NonFiniteNumber,
    #[error("tuple labels must be unique: '{0}'")]
    DuplicateTupleLabel(String),
    #[error("invalid artifact path '{path}': {reason}")]
    InvalidArtifactPath { path: String, reason: &'static str },
    #[error("duplicate artifact path '{0}'")]
    DuplicateArtifactPath(String),
    #[error("artifact tree entries cannot be symlinks: '{0}'")]
    SymlinkArtifact(String),
    #[error("self-hash projection must be a JSON object")]
    InvalidSelfHashProjection,
    #[error("invalid {projection} projection: {reason}")]
    InvalidProjection {
        projection: &'static str,
        reason: String,
    },
    #[error("program ID is missing from the IDL and no explicit program ID was supplied")]
    MissingProgramId,
    #[error("program ID at '{location}' must be a string or null")]
    InvalidProgramIdLocation { location: &'static str },
    #[error("conflicting program IDs: {0}")]
    ConflictingProgramIds(String),
    #[error("failed to parse IDL: {0}")]
    InvalidIdl(String),
    #[error("serialization failed: {0}")]
    Serialization(String),
}

impl HashError {
    /// Stable error category used by language-neutral conformance vectors.
    pub fn code(&self) -> &'static str {
        match self {
            Self::InvalidHashId(_) => "invalid-hash-id",
            Self::UnknownVersion(_) => "unknown-version",
            Self::UnknownKind(_) => "unknown-kind",
            Self::UnexpectedKind { .. } => "unexpected-kind",
            Self::UnknownAlgorithm(_) => "unknown-algorithm",
            Self::ProfileMismatch { .. } => "profile-mismatch",
            Self::InvalidJson(_) => "invalid-json",
            Self::DuplicateJsonKey(_) => "duplicate-json-key",
            Self::UnsafeJsonInteger(_) => "unsafe-json-integer",
            Self::NonFiniteNumber => "non-finite-number",
            Self::DuplicateTupleLabel(_) => "duplicate-tuple-label",
            Self::InvalidArtifactPath { .. } => "invalid-artifact-path",
            Self::DuplicateArtifactPath(_) => "duplicate-artifact-path",
            Self::SymlinkArtifact(_) => "symlink-artifact",
            Self::InvalidSelfHashProjection => "invalid-self-hash-projection",
            Self::InvalidProjection { .. } => "invalid-projection",
            Self::MissingProgramId => "missing-program-id",
            Self::InvalidProgramIdLocation { .. } => "invalid-program-id-location",
            Self::ConflictingProgramIds(_) => "conflicting-program-ids",
            Self::InvalidIdl(_) => "invalid-idl",
            Self::Serialization(_) => "serialization",
        }
    }
}

impl From<serde_json::Error> for HashError {
    fn from(error: serde_json::Error) -> Self {
        Self::Serialization(error.to_string())
    }
}