Struct ReportFooter 

pub struct ReportFooter {
    pub message: String,
    pub notes: Vec<String>,
    pub summary: bool,
}

Fields

message: String

notes: Vec<String>

summary: bool

Implementations

impl ReportFooter

A footer for a report.

A footer is a message that is displayed at the end of a report.

pub fn new<M: Into<String>>(message: M) -> Self

Create a new footer.

Examples found in repository

examples/simple.rs (line 44)

fn main() -> Result<(), Error> {
    let origin = "example.ara";
    let code = r#"
$b = match $a {
    1 => 2,
    2 => 3,
    default => "string",
};
"#;

    let map = SourceMap::new(vec![Source::new(SourceKind::Script, origin, code)]);

    let report = Report::new()
        .with_issue(
            Issue::error("E0417", "`match` arms have incompatible types")
                .with_source(origin, 6, 67)
                .with_annotation(
                    Annotation::secondary(origin, 26, 27)
                        .with_message("this is found to be of type `{int}`"),
                )
                .with_annotation(
                    Annotation::secondary(origin, 38, 39)
                        .with_message("this is found to be of type `{int}`"),
                )
                .with_annotation(
                    Annotation::secondary(origin, 56, 64)
                        .with_message("expected `{int}`, found `{string}`"),
                )
                .with_note("for more information about this error, try `ara --explain E0417`"),
        )
        .with_footer(
            ReportFooter::new("this is a report footer message")
                .with_note("this is a note message"),
        );

    let builder = ReportBuilder::new(&map)
        .with_colors(ColorChoice::Always)
        .with_charset(CharSet::Unicode);

    builder.print(&report)
}

examples/collection.rs (line 53)

fn main() -> Result<(), Error> {
    let first_origin = "example.ara";
    let first_code = r#"
$b = match $a {
    1 => 2,
    2 => 3,
    default => "string",
};
"#;

    let second_origin = "example-2.ara";
    let second_code = r#"
function foo(Bar&float) {}
"#;

    let map = SourceMap::new(vec![
        Source::new(SourceKind::Script, first_origin, first_code),
        Source::new(SourceKind::Script, second_origin, second_code),
    ]);

    let first_report = Report::new()
        .with_issue(
            Issue::error("E0417", "`match` arms have incompatible types")
                .with_source(first_origin, 6, 67)
                .with_annotation(
                    Annotation::secondary(first_origin, 26, 27)
                        .with_message("this is found to be of type `{int}`"),
                )
                .with_annotation(
                    Annotation::secondary(first_origin, 38, 39)
                        .with_message("this is found to be of type `{int}`"),
                )
                .with_annotation(
                    Annotation::secondary(first_origin, 56, 64)
                        .with_message("expected `{int}`, found `{string}`"),
                )
                .with_note("for more information about this error, try `ara --explain E0417`"),
        )
        .with_footer(
            ReportFooter::new("this is a report footer message")
                .with_note("this is a note message"),
        );

    let second_report = Report::new()
        .with_issue(
            Issue::error(
                "P0015",
                "scalar type `float` cannot be used in an intersection",
            )
            .with_source(second_origin, 18, 23)
            .with_annotation(
                Annotation::secondary(second_origin, 17, 19)
                    .with_message("scalar type `float` cannot be used in an intersection"),
            )
            .with_note("a scalar type is either `int`, `float`, `string`, or `bool`.")
            .with_note("try using a different type for the intersection."),
        )
        .with_issue(Issue::bug("B0001", "failed to read the file"))
        .with_footer(
            ReportFooter::new("this is a report footer message")
                .with_note("this is a note message"),
        );

    let reports: ReportCollection = vec![&first_report, &second_report];

    let builder = ReportBuilder::new(&map)
        .with_colors(ColorChoice::Always)
        .with_charset(CharSet::Unicode);

    builder.print(&reports)
}

examples/example.rs (line 100)

fn main() -> Result<(), Error> {
    let map = SourceMap::new(vec![Source::inline(
        SourceKind::Script,
        r#"
function main(): int|string {
    $a = 1;
    $b = 2;

    $c = $a + $b;

    $b = match ($a) {
        1 => 2,
        2 => 3,
        default => "string",
    };

    return $c + $b;
}
"#,
    )]);

    let report = Report::new()
        .with_issue(
            Issue::error("E123", "some error here")
                .with_source(DEFAULT_NAME, 35, 41)
                .with_annotation(
                    Annotation::secondary(DEFAULT_NAME, 41, 42).with_message("an annotation"),
                )
                .with_note("this is a note"),
        )
        .with_issue(
            Issue::warning("W123", "some warning here")
                .with_source(DEFAULT_NAME, 29, 187)
                .with_annotation(
                    Annotation::secondary(DEFAULT_NAME, 126, 127).with_message("an annotation"),
                )
                .with_note("this is a note"),
        )
        .with_issue(
            Issue::warning("W124", "some warning here")
                .with_source(DEFAULT_NAME, 29, 187)
                .with_annotation(
                    Annotation::secondary(DEFAULT_NAME, 126, 127).with_message("an annotation"),
                )
                .with_note("this is a note"),
        )
        .with_issue(
            Issue::note("N123", "some note here")
                .with_source(DEFAULT_NAME, 84, 163)
                .with_annotation(
                    Annotation::secondary(DEFAULT_NAME, 105, 112).with_message("an annotation"),
                )
                .with_annotation(
                    Annotation::secondary(DEFAULT_NAME, 121, 128)
                        .with_message("another annotation"),
                )
                .with_annotation(
                    Annotation::secondary(DEFAULT_NAME, 137, 147).with_message("and another"),
                )
                .with_note("this is a note"),
        )
        .with_issue(
            Issue::help("H123", "some help here")
                .with_source(DEFAULT_NAME, 137, 147)
                .with_annotation(
                    Annotation::secondary(DEFAULT_NAME, 35, 42).with_message("an annotation"),
                )
                .with_note("this is a note"),
        )
        .with_issue(
            Issue::bug("E123", "`match` arms have incompatible types")
                .with_source(DEFAULT_NAME, 84, 163)
                .with_annotation(
                    Annotation::secondary(DEFAULT_NAME, 110, 111)
                        .with_message("this is found to be of type `{int}`"),
                )
                .with_annotation(
                    Annotation::secondary(DEFAULT_NAME, 126, 127)
                        .with_message("this is found to be of type `{int}`"),
                )
                .with_annotation(
                    Annotation::secondary(DEFAULT_NAME, 148, 156)
                        .with_message("expected `{int}`, found `{string}`"),
                )
                .with_note("for more information about this error, try `ara --explain E0308`"),
        )
        .with_footer(ReportFooter::new("this is a report footer message"));

    let builder = ReportBuilder::new(&map)
        .with_colors(ColorChoice::Always)
        .with_charset(CharSet::Unicode);

    builder.print(&report)
}

pub fn with_note<S: Into<String>>(self, note: S) -> Self

Add a note to this footer.

Examples found in repository

examples/simple.rs (line 45)

fn main() -> Result<(), Error> {
    let origin = "example.ara";
    let code = r#"
$b = match $a {
    1 => 2,
    2 => 3,
    default => "string",
};
"#;

    let map = SourceMap::new(vec![Source::new(SourceKind::Script, origin, code)]);

    let report = Report::new()
        .with_issue(
            Issue::error("E0417", "`match` arms have incompatible types")
                .with_source(origin, 6, 67)
                .with_annotation(
                    Annotation::secondary(origin, 26, 27)
                        .with_message("this is found to be of type `{int}`"),
                )
                .with_annotation(
                    Annotation::secondary(origin, 38, 39)
                        .with_message("this is found to be of type `{int}`"),
                )
                .with_annotation(
                    Annotation::secondary(origin, 56, 64)
                        .with_message("expected `{int}`, found `{string}`"),
                )
                .with_note("for more information about this error, try `ara --explain E0417`"),
        )
        .with_footer(
            ReportFooter::new("this is a report footer message")
                .with_note("this is a note message"),
        );

    let builder = ReportBuilder::new(&map)
        .with_colors(ColorChoice::Always)
        .with_charset(CharSet::Unicode);

    builder.print(&report)
}

examples/collection.rs (line 54)

fn main() -> Result<(), Error> {
    let first_origin = "example.ara";
    let first_code = r#"
$b = match $a {
    1 => 2,
    2 => 3,
    default => "string",
};
"#;

    let second_origin = "example-2.ara";
    let second_code = r#"
function foo(Bar&float) {}
"#;

    let map = SourceMap::new(vec![
        Source::new(SourceKind::Script, first_origin, first_code),
        Source::new(SourceKind::Script, second_origin, second_code),
    ]);

    let first_report = Report::new()
        .with_issue(
            Issue::error("E0417", "`match` arms have incompatible types")
                .with_source(first_origin, 6, 67)
                .with_annotation(
                    Annotation::secondary(first_origin, 26, 27)
                        .with_message("this is found to be of type `{int}`"),
                )
                .with_annotation(
                    Annotation::secondary(first_origin, 38, 39)
                        .with_message("this is found to be of type `{int}`"),
                )
                .with_annotation(
                    Annotation::secondary(first_origin, 56, 64)
                        .with_message("expected `{int}`, found `{string}`"),
                )
                .with_note("for more information about this error, try `ara --explain E0417`"),
        )
        .with_footer(
            ReportFooter::new("this is a report footer message")
                .with_note("this is a note message"),
        );

    let second_report = Report::new()
        .with_issue(
            Issue::error(
                "P0015",
                "scalar type `float` cannot be used in an intersection",
            )
            .with_source(second_origin, 18, 23)
            .with_annotation(
                Annotation::secondary(second_origin, 17, 19)
                    .with_message("scalar type `float` cannot be used in an intersection"),
            )
            .with_note("a scalar type is either `int`, `float`, `string`, or `bool`.")
            .with_note("try using a different type for the intersection."),
        )
        .with_issue(Issue::bug("B0001", "failed to read the file"))
        .with_footer(
            ReportFooter::new("this is a report footer message")
                .with_note("this is a note message"),
        );

    let reports: ReportCollection = vec![&first_report, &second_report];

    let builder = ReportBuilder::new(&map)
        .with_colors(ColorChoice::Always)
        .with_charset(CharSet::Unicode);

    builder.print(&reports)
}

pub fn with_summary(self, enabled: bool) -> Self

Defines if either the summary should be enabled or disabled

Trait Implementations

impl Clone for ReportFooter

fn clone(&self) -> ReportFooter

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ReportFooter

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ReportFooter

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl JsonSchema for ReportFooter

fn schema_name() -> String

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn is_referenceable() -> bool

Whether JSON Schemas generated for this type should be re-used where possible using the $ref keyword.

impl PartialEq for ReportFooter

fn eq(&self, other: &ReportFooter) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for ReportFooter

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for ReportFooter

impl StructuralPartialEq for ReportFooter