icookforms 0.1.0

The World's Reference Cookie Audit Software - Complete Security & Compliance Analysis
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

//! Report generation module
//!
//! Supports multiple output formats: JSON, CSV, PDF, HTML

pub mod csv;
pub mod html;
pub mod json;
pub mod pdf;

use crate::types::{AnalysisResult, Error, Result};
use std::path::Path;

/// Report format enum
#[derive(Debug, Clone, Copy)]
pub enum ReportFormat {
    /// JSON report format
    Json,
    /// CSV report format for spreadsheets
    Csv,
    /// PDF report format for professional documents
    Pdf,
    /// HTML report format for web viewing
    Html,
}

/// Main reporter struct
pub struct Reporter {
    format: ReportFormat,
}

impl Reporter {
    /// Create a new reporter with specified format
    #[must_use]
    pub fn new(format: ReportFormat) -> Self {
        Self { format }
    }

    /// Generate report and save to file
    pub fn generate(&self, results: &AnalysisResult, output_path: &Path) -> Result<()> {
        match self.format {
            ReportFormat::Json => json::generate(results, output_path),
            ReportFormat::Csv => csv::generate(results, output_path),
            ReportFormat::Pdf => pdf::generate(results, output_path),
            ReportFormat::Html => html::generate(results, output_path),
        }
    }

    /// Generate report as string
    pub fn generate_string(&self, results: &AnalysisResult) -> Result<String> {
        match self.format {
            ReportFormat::Json => json::generate_string(results),
            ReportFormat::Csv => csv::generate_string(results),
            ReportFormat::Pdf => Err(Error::reporter("PDF cannot be generated as string")),
            ReportFormat::Html => html::generate_string(results),
        }
    }
}

impl ReportFormat {
    /// Parse format from string
    pub fn from_string(s: &str) -> Result<Self> {
        match s.to_lowercase().as_str() {
            "json" => Ok(Self::Json),
            "csv" => Ok(Self::Csv),
            "pdf" => Ok(Self::Pdf),
            "html" => Ok(Self::Html),
            _ => Err(Error::reporter(format!("Unknown format: {s}"))),
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_format_parsing() {
        assert!(matches!(
            ReportFormat::from_string("json").unwrap(),
            ReportFormat::Json
        ));
        assert!(matches!(
            ReportFormat::from_string("HTML").unwrap(),
            ReportFormat::Html
        ));
    }
}