nu-lint 1.2.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
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131

use nu_protocol::{
    Span,
    ast::{Argument, Call, Expr},
};

use crate::{
    LintLevel,
    ast::string::bare_glob_needs_quotes,
    context::LintContext,
    rule::{DetectFix, Rule},
    violation::{Detection, Fix, Replacement},
};

struct FixData {
    quoted_span: Span,
    pattern: String,
}

/// Checks if a string contains glob metacharacters
fn has_glob_chars(content: &str) -> bool {
    content.contains('*') || content.contains('?')
}

/// Checks a single call expression for quoted glob patterns
fn check_call(call: &Call, ctx: &LintContext) -> Vec<(Detection, FixData)> {
    let mut results = vec![];

    for arg in &call.arguments {
        let (Argument::Positional(arg_expr) | Argument::Unknown(arg_expr)) = arg else {
            continue;
        };

        // Check if this is a quoted glob pattern (GlobPattern with is_quoted=true)
        let Expr::GlobPattern(pattern, is_quoted) = &arg_expr.expr else {
            continue;
        };

        // Only flag quoted glob patterns (ones that won't expand)
        if !is_quoted {
            continue;
        }

        // Only flag if the pattern actually contains glob metacharacters
        if !has_glob_chars(pattern) {
            continue;
        }

        // Create violation
        let cmd_name = ctx.working_set.get_decl(call.decl_id).name().to_string();

        let violation = Detection::from_global_span(
            format!(
                "Quoted glob pattern `\"{pattern}\"` passed to `{cmd_name}` won't expand to match \
                 files"
            ),
            arg_expr.span,
        )
        .with_primary_label("use unquoted glob or glob subexpression");

        results.push((
            violation,
            FixData {
                quoted_span: arg_expr.span,
                pattern: pattern.clone(),
            },
        ));
    }

    results
}

struct GlobMayDropQuotes;

impl DetectFix for GlobMayDropQuotes {
    type FixInput<'a> = FixData;

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

    fn short_description(&self) -> &'static str {
        "Quoted glob pattern treated as literal"
    }

    fn source_link(&self) -> Option<&'static str> {
        Some("https://www.nushell.sh/lang-guide/chapters/types/basic_types/glob.html")
    }

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

    fn detect<'a>(&self, context: &'a LintContext) -> Vec<(Detection, Self::FixInput<'a>)> {
        context.detect_with_fix_data(|expr, ctx| {
            let Expr::Call(call) = &expr.expr else {
                return vec![];
            };

            check_call(call, ctx)
        })
    }

    fn fix(&self, _context: &LintContext, fix_data: &Self::FixInput<'_>) -> Option<Fix> {
        let can_be_bare = !bare_glob_needs_quotes(&fix_data.pattern);
        let replacement_text = if can_be_bare {
            fix_data.pattern.clone()
        } else {
            format!("(\"{}\" | into glob)", fix_data.pattern)
        };

        let explanation = if can_be_bare {
            format!("Remove quotes from glob pattern '{replacement_text}'")
        } else {
            format!("Convert quoted pattern to glob using '{replacement_text}'")
        };

        Some(Fix {
            explanation: explanation.into(),
            replacements: vec![Replacement::new(fix_data.quoted_span, replacement_text)],
        })
    }
}

pub static RULE: &dyn Rule = &GlobMayDropQuotes;

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