only-semantic 0.1.0

Semantic analysis for the only task language.
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

use smol_str::SmolStr;
use text_size::TextRange;

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct DocumentAst {
    pub directives: Vec<DirectiveAst>,
    pub namespaces: Vec<NamespaceAst>,
    pub tasks: Vec<TaskAst>,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum DirectiveAst {
    Version {
        major: u64,
        minor: u64,
        range: TextRange,
    },
    Shell {
        shell: SmolStr,
        range: TextRange,
    },
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct NamespaceAst {
    pub name: SmolStr,
    pub doc: Option<SmolStr>,
    pub range: TextRange,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct TaskAst {
    pub name: SmolStr,
    pub namespace: Option<SmolStr>,
    pub doc: Option<SmolStr>,
    pub params: Vec<ParamAst>,
    pub guard: Option<GuardAst>,
    pub dependencies: Vec<DependencyAst>,
    pub shell: Option<SmolStr>,
    pub shell_fallback: bool,
    pub commands: Vec<CommandAst>,
    pub range: TextRange,
}

impl TaskAst {
    pub fn qualified_name(&self) -> SmolStr {
        match &self.namespace {
            Some(namespace) => SmolStr::from(format!("{namespace}.{}", self.name)),
            None => self.name.clone(),
        }
    }

    pub fn signature(&self) -> SmolStr {
        let mut signature = self.name.to_string();
        signature.push('(');
        signature.push_str(
            &self
                .params
                .iter()
                .map(
                    |parameter| match (parameter.is_slice, &parameter.default_value) {
                        (true, Some(default)) => format!("{}..=\"{default}\"", parameter.name),
                        (true, None) => format!("{}..", parameter.name),
                        (false, Some(default)) => format!("{}=\"{default}\"", parameter.name),
                        (false, None) => parameter.name.to_string(),
                    },
                )
                .collect::<Vec<_>>()
                .join(", "),
        );
        signature.push(')');
        SmolStr::from(signature)
    }

    /// Returns whether the task is a helper task hidden from normal CLI listings.
    ///
    /// Args:
    /// None.
    ///
    /// Returns:
    /// `true` when the task name starts with `_`.
    pub fn is_helper(&self) -> bool {
        self.name.starts_with('_')
    }
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ParamAst {
    pub name: SmolStr,
    pub default_value: Option<SmolStr>,
    pub is_slice: bool,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct GuardAst {
    pub kind: SmolStr,
    pub argument: SmolStr,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct DependencyAst {
    pub name: SmolStr,
    pub range: TextRange,
    pub stage: usize,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct CommandAst {
    pub text: SmolStr,
    pub interpolations: Vec<InterpolationAst>,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct InterpolationAst {
    pub name: SmolStr,
    pub range: TextRange,
}