qubit-mime 0.2.0

MIME type detection utilities for Rust based on filename glob rules and content magic
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

/*******************************************************************************
 *
 *    Copyright (c) 2026 Haixing Hu.
 *
 *    SPDX-License-Identifier: Apache-2.0
 *
 *    Licensed under the Apache License, Version 2.0.
 *
 ******************************************************************************/
//! Coverage helpers for default classifier selection.

use std::path::Path;
use std::sync::Arc;

use crate::{ArcMediaStreamClassifier, BoxMediaStreamClassifier, MediaStreamClassifier};

use super::FfprobeCommandMediaStreamClassifier;
use super::media_stream_classifier_backend::MediaStreamClassifierBackend;

/// Exercises optional default classifier selection.
///
/// # Returns
/// Summary strings from default classifier lookups.
pub(crate) fn exercise_classifier_defaults() -> Vec<String> {
    let boxed_wrapper =
        BoxMediaStreamClassifier::new(Box::new(FfprobeCommandMediaStreamClassifier::new()));
    let boxed_as_classifier = boxed_wrapper
        .as_ref()
        .classify_content(b"media")
        .is_ok()
        .to_string();
    let boxed_deref = std::ops::Deref::deref(&boxed_wrapper)
        .classify_content(b"media")
        .is_ok()
        .to_string();
    let boxed_content = boxed_wrapper.classify_content(b"media").is_ok().to_string();
    let boxed_file = boxed_wrapper
        .classify_file(Path::new("Cargo.toml"))
        .is_ok()
        .to_string();
    let boxed_inner = boxed_wrapper
        .into_inner()
        .classify_content(b"media")
        .is_ok()
        .to_string();
    let boxed_trait: Box<dyn MediaStreamClassifier> =
        Box::new(FfprobeCommandMediaStreamClassifier::new());
    let boxed_from_trait = BoxMediaStreamClassifier::from(boxed_trait);
    let boxed_into_trait: Box<dyn MediaStreamClassifier> = boxed_from_trait.into();
    let boxed_from_into = boxed_into_trait
        .classify_content(b"media")
        .is_ok()
        .to_string();

    let arc_wrapper =
        ArcMediaStreamClassifier::new(Arc::new(FfprobeCommandMediaStreamClassifier::new()));
    let arc_as_classifier = arc_wrapper
        .as_ref()
        .classify_content(b"media")
        .is_ok()
        .to_string();
    let arc_deref = std::ops::Deref::deref(&arc_wrapper)
        .classify_content(b"media")
        .is_ok()
        .to_string();
    let arc_content = arc_wrapper.classify_content(b"media").is_ok().to_string();
    let arc_file = arc_wrapper
        .classify_file(Path::new("Cargo.toml"))
        .is_ok()
        .to_string();
    let arc_inner = arc_wrapper
        .into_inner()
        .classify_content(b"media")
        .is_ok()
        .to_string();
    let arc_trait: Arc<dyn MediaStreamClassifier> =
        Arc::new(FfprobeCommandMediaStreamClassifier::new());
    let arc_from_trait = ArcMediaStreamClassifier::from(arc_trait);
    let arc_into_trait: Arc<dyn MediaStreamClassifier> = arc_from_trait.into();
    let arc_from_into = arc_into_trait
        .classify_content(b"media")
        .is_ok()
        .to_string();

    vec![
        BoxMediaStreamClassifier::default()
            .classify_content(b"media")
            .is_ok()
            .to_string(),
        BoxMediaStreamClassifier::from_name("ffprobe")
            .is_some()
            .to_string(),
        BoxMediaStreamClassifier::from_name("unknown")
            .is_none()
            .to_string(),
        boxed_as_classifier,
        boxed_deref,
        boxed_content,
        boxed_file,
        boxed_inner,
        boxed_from_into,
        format!("{:?}", MediaStreamClassifierBackend::select("")),
        format!("{:?}", MediaStreamClassifierBackend::select("unknown")),
        format!("{:?}", MediaStreamClassifierBackend::select("ffprobe")),
        ArcMediaStreamClassifier::default()
            .classify_content(b"media")
            .is_ok()
            .to_string(),
        ArcMediaStreamClassifier::from_name("ffprobe")
            .is_some()
            .to_string(),
        ArcMediaStreamClassifier::from_name("unknown")
            .is_none()
            .to_string(),
        arc_as_classifier,
        arc_deref,
        arc_content,
        arc_file,
        arc_inner,
        arc_from_into,
    ]
}