feature-manifest 0.7.6

Document, validate, and render Cargo feature metadata.
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

use std::fs;
use std::path::Path;

use serde_json::json;

use crate::cli::commands::check::PackageReport;
use crate::cli::output::github::issue_message;
use crate::cli::util::portable_relative_path;
use crate::{ManifestSourceMap, Severity, WorkspaceManifest, lint_docs};

pub fn render(
    workspace: &WorkspaceManifest,
    package_reports: &[PackageReport<'_>],
) -> serde_json::Value {
    let root_directory = workspace
        .root_manifest_path
        .parent()
        .unwrap_or_else(|| Path::new("."));

    let rules = lint_docs()
        .iter()
        .map(|lint| {
            json!({
                "id": lint.code,
                "name": lint.code,
                "shortDescription": { "text": lint.summary },
                "help": { "text": lint.guidance },
            })
        })
        .collect::<Vec<_>>();

    let results = package_reports
        .iter()
        .flat_map(|(package, report)| {
            let source = fs::read_to_string(&package.manifest_path).ok();
            report.issues.iter().map(move |issue| {
                let mut physical_location = json!({
                    "artifactLocation": {
                        "uri": portable_relative_path(root_directory, &package.manifest_path),
                    }
                });

                if let Some(span) = source
                    .as_deref()
                    .and_then(|source| ManifestSourceMap::new(source).span_for_issue(issue))
                {
                    physical_location["region"] = json!({
                        "startLine": span.line,
                        "startColumn": span.column,
                    });
                }

                json!({
                    "ruleId": issue.code,
                    "level": match issue.severity {
                        Severity::Warning => "warning",
                        Severity::Error => "error",
                    },
                    "message": {
                        "text": issue_message(package, issue),
                    },
                    "locations": [
                        {
                            "physicalLocation": physical_location,
                        }
                    ]
                })
            })
        })
        .collect::<Vec<_>>();

    json!({
        "$schema": "https://json.schemastore.org/sarif-2.1.0.json",
        "version": "2.1.0",
        "runs": [
            {
                "tool": {
                    "driver": {
                        "name": "feature-manifest",
                        "informationUri": "https://github.com/funwithcthulhu/feature-manifest",
                        "rules": rules,
                    }
                },
                "results": results,
            }
        ]
    })
}