Sign in

    zhaoyuanjuns/moonbit_extractor/reporting does not have a README file

    AuditReport

    pub(all) struct AuditReport {
    name : String
    findings : Array[Finding]
    passed : Bool
    score : Double
    } derive(Eq, ToJson,
    Debug
    )

    AuditReport::add

    fn AuditReport::add(self : AuditReport, finding : Finding) -> AuditReport

    AuditReport::finding_count

    fn AuditReport::finding_count(self : AuditReport, severity : Severity) -> Int

    AuditReport::new

    fn AuditReport::new(name~ : String) -> AuditReport

    AuditReport::to_csv

    fn AuditReport::to_csv(self : AuditReport) -> String

    AuditReport::to_markdown

    fn AuditReport::to_markdown(self : AuditReport) -> String

    ExportManifest

    pub(all) struct ExportManifest {
    format : String
    title : String
    record_count : Int
    generated_by : String
    fields : Array[String]
    } derive(Eq, ToJson,
    Debug
    )

    Finding

    pub(all) struct Finding {
    code : String
    severity : Severity
    title : String
    detail : String
    measured : Double
    limit : Double
    } derive(Eq, ToJson,
    Debug
    )

    Finding::fail

    fn Finding::fail(code~ : String, title~ : String, measured~ : Double, limit~ : Double, detail~ : String) -> Finding

    Finding::notice

    fn Finding::notice(code~ : String, title~ : String, measured~ : Double, limit~ : Double, detail~ : String) -> Finding

    Finding::pass

    fn Finding::pass(code~ : String, title~ : String, measured~ : Double, limit~ : Double, detail~ : String) -> Finding

    KeyValue

    pub(all) struct KeyValue {
    key : String
    value : String
    } derive(Eq, ToJson,
    Debug
    )

    Stable, machine-readable exports for reports and engineering results.

    ReportBlock

    pub(all) enum ReportBlock {
    Heading(level~ : Int, text~ : String)
    Paragraph(text~ : String)
    Bullet(items~ : Array[String])
    Table(table~ : ReportTable)
    Finding(finding~ : Finding)
    Metric(name~ : String, value~ : Double, unit~ : String)
    Divider
    } derive(Eq, ToJson,
    Debug
    )

    ReportDocument

    pub(all) struct ReportDocument {
    title : String
    subtitle : String
    blocks : Array[ReportBlock]
    generated_by : String
    } derive(Eq, ToJson,
    Debug
    )

    ReportDocument::add

    ReportDocument::block_count

    fn ReportDocument::block_count(self : ReportDocument) -> Int

    ReportDocument::bullets

    fn ReportDocument::bullets(self : ReportDocument, items~ : Array[String]) -> ReportDocument

    ReportDocument::finding

    fn ReportDocument::finding(self : ReportDocument, finding~ : Finding) -> ReportDocument

    ReportDocument::heading

    ReportDocument::index

    ReportDocument::metric

    fn ReportDocument::metric(self : ReportDocument, name~ : String, value~ : Double, unit~ : String) -> ReportDocument raise
    ExtractionError

    ReportDocument::new

    fn ReportDocument::new(title~ : String, subtitle? : String, generated_by? : String) -> ReportDocument raise
    ExtractionError

    ReportDocument::paragraph

    fn ReportDocument::paragraph(self : ReportDocument, text~ : String) -> ReportDocument

    ReportDocument::summary

    fn ReportDocument::summary(self : ReportDocument) -> String

    ReportDocument::table

    ReportDocument::to_markdown

    fn ReportDocument::to_markdown(self : ReportDocument) -> String

    ReportIndex

    pub(all) struct ReportIndex {
    title : String
    section_count : Int
    metric_count : Int
    table_count : Int
    failure_count : Int
    } derive(Eq, ToJson,
    Debug
    )

    ReportTable

    pub(all) struct ReportTable {
    title : String
    columns : Array[String]
    rows : Array[Array[String]]
    numeric_columns : Array[Bool]
    } derive(Eq, ToJson,
    Debug
    )

    A typed table used in engineering reports.

    ReportTable::column_count

    fn ReportTable::column_count(self : ReportTable) -> Int

    ReportTable::new

    fn ReportTable::new(title~ : String, columns~ : ArrayView[String], numeric_columns? : ArrayView[Bool]) -> ReportTable raise
    ExtractionError

    ReportTable::row_count

    fn ReportTable::row_count(self : ReportTable) -> Int

    ReportTable::rows

    fn ReportTable::rows(self : ReportTable) -> Array[Array[String]]

    ReportTable::to_csv

    fn ReportTable::to_csv(self : ReportTable) -> String

    ReportTable::to_markdown

    fn ReportTable::to_markdown(self : ReportTable) -> String

    Severity

    pub(all) enum Severity {
    Pass
    Notice
    Fail
    } derive(Eq, ToJson,
    Debug
    )

    Human- and machine-readable audit summaries for process studies.

    analysis_balance_report

    Build a report from the analysis package's aggregate balance audit.

    balance_report

    fn balance_report(name~ : String, residuals : ArrayView[Double], tolerance~ : Double) -> AuditReport raise
    ExtractionError

    document_csv

    fn document_csv(document : ReportDocument) -> String

    document_html

    fn document_html(document : ReportDocument) -> String

    document_json_lines

    fn document_json_lines(document : ReportDocument) -> String

    document_manifest

    fn document_manifest(document : ReportDocument, format : String) -> ExportManifest

    document_outline

    fn document_outline(document : ReportDocument) -> Array[String]

    document_plain_text

    fn document_plain_text(document : ReportDocument) -> String

    escape_json_text

    fn escape_json_text(value : String) -> String

    export_checksum

    fn export_checksum(text : String) -> String

    key_value_json

    fn key_value_json(values : ArrayView[KeyValue]) -> String

    manifest_json

    fn manifest_json(manifest : ExportManifest) -> String

    manifest_summary

    fn manifest_summary(manifest : ExportManifest) -> String

    report_export

    fn report_export(document : ReportDocument, format : String) -> String raise
    ExtractionError

    report_export_formats

    fn report_export_formats() -> Array[String]

    report_from_audit

    report_has_format

    fn report_has_format(format : String) -> Bool

    table_to_html

    fn table_to_html(table : ReportTable) -> String

    table_to_tsv

    fn table_to_tsv(table : ReportTable) -> String