mojique 0.1.1

A safe Rust wrapper and pool implementation around libmagic
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
119
120
121
122
123
124
125
126
127
128
129
130
131
132

use std::collections::BTreeSet;

use common::*;
use insta::{assert_debug_snapshot, assert_snapshot};
use itertools::Itertools;
use mojique::{Config, DefaultConfig, Flag};
use rayon::iter::{IntoParallelIterator, ParallelIterator};

mod common;

#[test]
fn file() -> anyhow::Result<()> {
    let path = manifest_dir().join("tests/data/LICENSE.zst");

    // We won't try to enumerate every possible combination of flags, but let's ensure that at least
    // the obvious, common ones are handled.

    let mut handle = DefaultConfig::default().build_handle()?;
    let magic_type = handle.file(&path)?;
    assert_snapshot!(magic_type, @"Zstandard compressed data (v0.8+), Dictionary ID: None");

    let mut handle = DefaultConfig::default()
        .set_flag(Flag::Compress)
        .build_handle()?;
    let magic_type = handle.file(&path)?;
    assert_snapshot!(magic_type, @"ASCII text (Zstandard compressed data (v0.8+), Dictionary ID: None)");

    let mut handle = DefaultConfig::default()
        .set_flag(Flag::Compress)
        .set_flag(Flag::CompressTransparent)
        .build_handle()?;
    let magic_type = handle.file(&path)?;
    assert_snapshot!(magic_type, @"ASCII text");

    let mut handle = DefaultConfig::default()
        .set_flag(Flag::Mime)
        .build_handle()?;
    let magic_type = handle.file(&path)?;
    assert_snapshot!(magic_type, @"application/zstd; charset=binary");

    let mut handle = DefaultConfig::default()
        .set_flag(Flag::Compress)
        .set_flag(Flag::Mime)
        .build_handle()?;
    let magic_type = handle.file(&path)?;
    assert_snapshot!(magic_type, @"text/plain; charset=us-ascii compressed-encoding=application/zstd; charset=binary");

    let mut handle = DefaultConfig::default()
        .set_flag(Flag::Extension)
        .build_handle()?;
    let magic_type = handle.file(&path)?;
    assert_snapshot!(magic_type, @"zst");

    let mut handle = DefaultConfig::default()
        .set_flag(Flag::Compress)
        .set_flag(Flag::Extension)
        .build_handle()?;
    let magic_type = handle.file(path)?;
    assert_snapshot!(magic_type, @"??? (zst)");
    Ok(())
}

#[test]
fn not_exist() -> anyhow::Result<()> {
    let mut handle = DefaultConfig::default().build_handle()?;
    let e = handle
        .file("this-file-should-not-exist")
        .expect_err("file not found");
    assert_debug_snapshot!(e, @r#"
    Magic {
        errno: 2,
        message: Message(
            "cannot stat `this-file-should-not-exist' (No such file or directory)",
        ),
    }
    "#);

    Ok(())
}

#[test]
fn symlink() -> anyhow::Result<()> {
    let path = manifest_dir().join("tests/data/symlink");

    // Don't follow the link.
    let mut handle = DefaultConfig::default().build_handle()?;
    let magic_type = handle.file(&path)?;
    assert_snapshot!(magic_type, @"symbolic link to LICENSE.zst");

    // Follow the link.
    let mut handle = DefaultConfig::default()
        .set_flag(Flag::Symlink)
        .build_handle()?;
    let magic_type = handle.file(&path)?;
    assert_snapshot!(magic_type, @"Zstandard compressed data (v0.8+), Dictionary ID: None");

    // Follow the link and decompress.
    let mut handle = DefaultConfig::default()
        .set_flag(Flag::Compress)
        .set_flag(Flag::Symlink)
        .build_handle()?;
    let magic_type = handle.file(path)?;
    assert_snapshot!(magic_type, @"ASCII text (Zstandard compressed data (v0.8+), Dictionary ID: None)");

    Ok(())
}

#[test]
fn parallel() -> anyhow::Result<()> {
    const ITERATIONS: usize = 1000;

    let pool = DefaultConfig::default().build_pool()?;

    // Basically, we'll use rayon to create a pool of shared handles, one per thread, and then make
    // sure that every iteration returned the same value.
    let types: BTreeSet<String> = (0..ITERATIONS)
        .map(|_| manifest_dir().join("LICENSE"))
        .collect_vec()
        .into_par_iter()
        .map(|path| -> Result<String, mojique::Error> { pool.handle()?.file(path) })
        .collect::<Vec<_>>()
        .into_iter()
        .try_collect()?;

    assert_debug_snapshot!(types, @r#"
    {
        "ASCII text",
    }
    "#);

    Ok(())
}