wholesum 0.2.1

Wholesome collection of file hashing algorithms all bundled in a single tool. Like sha256sum, b3sum and others, but one: the whole-sum.
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

use std::{
    fs::File,
    io::{BufRead, BufReader},
    path::PathBuf,
    str::FromStr,
};

use anyhow::{Context, Result};

use crate::{Algorithm, Mode};

#[derive(Debug)]
pub struct HashFile {
    pub algorithm: Option<Algorithm>,
    pub entries: Vec<HashEntry>,
}

impl HashFile {
    pub fn parse(file: PathBuf) -> Result<Self> {
        Ok(Self {
            algorithm: None,
            entries: BufReader::new(File::open(file)?)
                .lines()
                .map(|line| line?.parse())
                .collect::<Result<_>>()?,
        })
    }
}

#[derive(Debug)]
pub struct HashEntry {
    pub algorithm: Option<Algorithm>,
    pub hash: String,
    pub mode: Mode,
    pub file: String,
}

impl FromStr for HashEntry {
    type Err = anyhow::Error;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        let mut parts = s.split_whitespace();
        let algo = parts.next().context("line too short")?;
        let hash = parts.next().context("line too short")?;
        let file = parts.next();

        let (algorithm, hash, file) = if let Some(file) = file {
            (Some(algo.parse()?), hash, file)
        } else {
            (None, algo, hash)
        };

        let hash = hash.to_owned();

        let mode = if file.starts_with('*') {
            Mode::Binary
        } else {
            Mode::Text
        };

        let file = file.strip_prefix('*').unwrap_or(file).to_owned();

        Ok(Self {
            algorithm,
            hash,
            mode,
            file,
        })
    }
}