ass-core 0.1.2

High-performance ASS subtitle format parser and analyzer
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

//! Shared mock implementations for plugin system tests.

use crate::plugin::{SectionProcessor, SectionResult, TagHandler, TagResult};
#[cfg(not(feature = "std"))]
use alloc::string::ToString;

/// Mock tag handler for testing
pub(super) struct MockTagHandler {
    name: &'static str,
    should_process: bool,
    should_fail: bool,
}

impl MockTagHandler {
    pub(super) fn new(name: &'static str) -> Self {
        Self {
            name,
            should_process: true,
            should_fail: false,
        }
    }

    pub(super) fn with_failure(mut self, should_fail: bool) -> Self {
        self.should_fail = should_fail;
        self
    }
}

impl TagHandler for MockTagHandler {
    fn name(&self) -> &'static str {
        self.name
    }

    fn process(&self, _args: &str) -> TagResult {
        if self.should_fail {
            TagResult::Failed("Mock failure".to_string())
        } else if self.should_process {
            TagResult::Processed
        } else {
            TagResult::Ignored
        }
    }

    fn validate(&self, args: &str) -> bool {
        !args.is_empty()
    }
}

/// Mock section processor for testing
pub(super) struct MockSectionProcessor {
    name: &'static str,
    should_process: bool,
    should_fail: bool,
}

impl MockSectionProcessor {
    pub(super) fn new(name: &'static str) -> Self {
        Self {
            name,
            should_process: true,
            should_fail: false,
        }
    }
}

impl SectionProcessor for MockSectionProcessor {
    fn name(&self) -> &'static str {
        self.name
    }

    fn process(&self, _header: &str, _lines: &[&str]) -> SectionResult {
        if self.should_fail {
            SectionResult::Failed("Mock failure".to_string())
        } else if self.should_process {
            SectionResult::Processed
        } else {
            SectionResult::Ignored
        }
    }

    fn validate(&self, header: &str, lines: &[&str]) -> bool {
        !header.is_empty() && !lines.is_empty()
    }
}