nu-lint 1.3.0

Linter for Nu shell scripts that helpfully suggests improvements
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

use nu_protocol::{Span, Type, ast::PipelineElement};

use crate::{
    Fix, Replacement,
    config::LintLevel,
    context::LintContext,
    format_conversions::{ConversionSpec, check_all_pipelines},
    rule::{DetectFix, Rule},
    violation::Detection,
};

struct StructuredDataToJsonTool;

impl DetectFix for StructuredDataToJsonTool {
    type FixInput<'a> = Span;

    fn id(&self) -> &'static str {
        "structured_data_to_json_tool"
    }

    fn short_description(&self) -> &'static str {
        "Data piped to JSON tool without `to json`"
    }

    fn source_link(&self) -> Option<&'static str> {
        Some("https://www.nushell.sh/book/pipelines.html#external-commands")
    }

    fn level(&self) -> LintLevel {
        LintLevel::Warning
    }

    fn detect<'a>(&self, context: &'a LintContext) -> Vec<(Detection, Self::FixInput<'a>)> {
        let spec = ConversionSpec {
            matches_command: &|cmd| matches!(cmd, "jq" | "json_pp" | "jsonlint"),
            matches_type: &|ty| matches!(ty, Type::Table(_) | Type::Record(_) | Type::List(_)),
        };

        check_all_pipelines(context, &spec, create_violation)
    }

    fn fix(&self, context: &LintContext, data_span: &Self::FixInput<'_>) -> Option<Fix> {
        let original_text = context.span_text(*data_span);
        let new_text = format!("{original_text} | to json");

        Some(Fix {
            explanation: "Add 'to json' to convert to JSON before piping to JSON tool".into(),
            replacements: vec![Replacement::new(*data_span, new_text)],
        })
    }
}

fn create_violation(
    ty: &Type,
    cmd_name: &str,
    left: &PipelineElement,
    right: &PipelineElement,
) -> (Detection, Span) {
    let type_name = ty.to_string();
    let message =
        format!("Piping {type_name} into JSON tool '{cmd_name}' requires 'to json' conversion");

    let detection = Detection::from_global_span(message, right.expr.span)
        .with_extra_label(format!("{type_name} output"), left.expr.span)
        .with_extra_label("JSON tool", right.expr.span);

    (detection, left.expr.span)
}

pub static RULE: &dyn Rule = &StructuredDataToJsonTool;

#[cfg(test)]
mod detect_bad;
#[cfg(test)]
mod generated_fix;
#[cfg(test)]
mod ignore_good;