1use nu_engine::command_prelude::*;
2use nu_protocol::ast::{Assignment, Bits, Boolean, Comparison, Math, Operator};
3
4#[derive(Clone)]
5pub struct HelpOperators;
6
7impl Command for HelpOperators {
8 fn name(&self) -> &str {
9 "help operators"
10 }
11
12 fn description(&self) -> &str {
13 "Show help on nushell operators."
14 }
15
16 fn signature(&self) -> Signature {
17 Signature::build("help operators")
18 .category(Category::Core)
19 .input_output_types(vec![(Type::Nothing, Type::table())])
20 .allow_variants_without_examples(true)
21 }
22
23 fn run(
24 &self,
25 _engine_state: &EngineState,
26 _stack: &mut Stack,
27 call: &Call,
28 _input: PipelineData,
29 ) -> Result<PipelineData, ShellError> {
30 let head = call.head;
31 let mut operators = [
32 Operator::Assignment(Assignment::Assign),
33 Operator::Assignment(Assignment::AddAssign),
34 Operator::Assignment(Assignment::SubtractAssign),
35 Operator::Assignment(Assignment::MultiplyAssign),
36 Operator::Assignment(Assignment::DivideAssign),
37 Operator::Assignment(Assignment::ConcatenateAssign),
38 Operator::Comparison(Comparison::Equal),
39 Operator::Comparison(Comparison::NotEqual),
40 Operator::Comparison(Comparison::LessThan),
41 Operator::Comparison(Comparison::GreaterThan),
42 Operator::Comparison(Comparison::LessThanOrEqual),
43 Operator::Comparison(Comparison::GreaterThanOrEqual),
44 Operator::Comparison(Comparison::RegexMatch),
45 Operator::Comparison(Comparison::NotRegexMatch),
46 Operator::Comparison(Comparison::In),
47 Operator::Comparison(Comparison::NotIn),
48 Operator::Comparison(Comparison::Has),
49 Operator::Comparison(Comparison::NotHas),
50 Operator::Comparison(Comparison::StartsWith),
51 Operator::Comparison(Comparison::EndsWith),
52 Operator::Math(Math::Add),
53 Operator::Math(Math::Subtract),
54 Operator::Math(Math::Multiply),
55 Operator::Math(Math::Divide),
56 Operator::Math(Math::FloorDivide),
57 Operator::Math(Math::Modulo),
58 Operator::Math(Math::Pow),
59 Operator::Math(Math::Concatenate),
60 Operator::Bits(Bits::BitOr),
61 Operator::Bits(Bits::BitXor),
62 Operator::Bits(Bits::BitAnd),
63 Operator::Bits(Bits::ShiftLeft),
64 Operator::Bits(Bits::ShiftRight),
65 Operator::Boolean(Boolean::Or),
66 Operator::Boolean(Boolean::Xor),
67 Operator::Boolean(Boolean::And),
68 ]
69 .into_iter()
70 .map(|op| {
71 if op == Operator::Comparison(Comparison::RegexMatch) {
72 Value::record(
73 record! {
74 "type" => Value::string(op_type(&op), head),
75 "operator" => Value::string("=~, like", head),
76 "name" => Value::string(name(&op), head),
77 "description" => Value::string(description(&op), head),
78 "precedence" => Value::int(op.precedence().into(), head),
79 },
80 head,
81 )
82 } else if op == Operator::Comparison(Comparison::NotRegexMatch) {
83 Value::record(
84 record! {
85 "type" => Value::string(op_type(&op), head),
86 "operator" => Value::string("!~, not-like", head),
87 "name" => Value::string(name(&op), head),
88 "description" => Value::string(description(&op), head),
89 "precedence" => Value::int(op.precedence().into(), head),
90 },
91 head,
92 )
93 } else {
94 Value::record(
95 record! {
96 "type" => Value::string(op_type(&op), head),
97 "operator" => Value::string(op.to_string(), head),
98 "name" => Value::string(name(&op), head),
99 "description" => Value::string(description(&op), head),
100 "precedence" => Value::int(op.precedence().into(), head),
101 },
102 head,
103 )
104 }
105 })
106 .collect::<Vec<_>>();
107
108 operators.push(Value::record(
109 record! {
110 "type" => Value::string("Boolean", head),
111 "operator" => Value::string("not", head),
112 "name" => Value::string("Not", head),
113 "description" => Value::string("Negates a value or expression.", head),
114 "precedence" => Value::int(55, head),
115 },
116 head,
117 ));
118
119 Ok(Value::list(operators, head).into_pipeline_data())
120 }
121}
122
123fn op_type(operator: &Operator) -> &'static str {
124 match operator {
125 Operator::Comparison(_) => "Comparison",
126 Operator::Math(_) => "Math",
127 Operator::Boolean(_) => "Boolean",
128 Operator::Bits(_) => "Bitwise",
129 Operator::Assignment(_) => "Assignment",
130 }
131}
132
133fn name(operator: &Operator) -> String {
134 match operator {
135 Operator::Comparison(op) => format!("{op:?}"),
136 Operator::Math(op) => format!("{op:?}"),
137 Operator::Boolean(op) => format!("{op:?}"),
138 Operator::Bits(op) => format!("{op:?}"),
139 Operator::Assignment(op) => format!("{op:?}"),
140 }
141}
142
143fn description(operator: &Operator) -> &'static str {
144 match operator {
146 Operator::Comparison(Comparison::Equal) => "Checks if two values are equal.",
147 Operator::Comparison(Comparison::NotEqual) => "Checks if two values are not equal.",
148 Operator::Comparison(Comparison::LessThan) => "Checks if a value is less than another.",
149 Operator::Comparison(Comparison::GreaterThan) => {
150 "Checks if a value is greater than another."
151 }
152 Operator::Comparison(Comparison::LessThanOrEqual) => {
153 "Checks if a value is less than or equal to another."
154 }
155 Operator::Comparison(Comparison::GreaterThanOrEqual) => {
156 "Checks if a value is greater than or equal to another."
157 }
158 Operator::Comparison(Comparison::RegexMatch) => {
159 "Checks if a value matches a regular expression."
160 }
161 Operator::Comparison(Comparison::NotRegexMatch) => {
162 "Checks if a value does not match a regular expression."
163 }
164 Operator::Comparison(Comparison::In) => {
165 "Checks if a value is in a list, is part of a string, or is a key in a record."
166 }
167 Operator::Comparison(Comparison::NotIn) => {
168 "Checks if a value is not in a list, is not part of a string, or is not a key in a record."
169 }
170 Operator::Comparison(Comparison::Has) => {
171 "Checks if a list contains a value, a string contains another, or if a record has a key."
172 }
173 Operator::Comparison(Comparison::NotHas) => {
174 "Checks if a list does not contain a value, a string does not contain another, or if a record does not have a key."
175 }
176 Operator::Comparison(Comparison::StartsWith) => "Checks if a string starts with another.",
177 Operator::Comparison(Comparison::EndsWith) => "Checks if a string ends with another.",
178 Operator::Math(Math::Add) => "Adds two values.",
179 Operator::Math(Math::Subtract) => "Subtracts two values.",
180 Operator::Math(Math::Multiply) => "Multiplies two values.",
181 Operator::Math(Math::Divide) => "Divides two values.",
182 Operator::Math(Math::FloorDivide) => "Divides two values and floors the result.",
183 Operator::Math(Math::Modulo) => "Divides two values and returns the remainder.",
184 Operator::Math(Math::Pow) => "Raises one value to the power of another.",
185 Operator::Math(Math::Concatenate) => {
186 "Concatenates two lists, two strings, or two binary values."
187 }
188 Operator::Boolean(Boolean::Or) => "Checks if either value is true.",
189 Operator::Boolean(Boolean::Xor) => "Checks if one value is true and the other is false.",
190 Operator::Boolean(Boolean::And) => "Checks if both values are true.",
191 Operator::Bits(Bits::BitOr) => "Performs a bitwise OR on two values.",
192 Operator::Bits(Bits::BitXor) => "Performs a bitwise XOR on two values.",
193 Operator::Bits(Bits::BitAnd) => "Performs a bitwise AND on two values.",
194 Operator::Bits(Bits::ShiftLeft) => "Bitwise shifts a value left by another.",
195 Operator::Bits(Bits::ShiftRight) => "Bitwise shifts a value right by another.",
196 Operator::Assignment(Assignment::Assign) => "Assigns a value to a variable.",
197 Operator::Assignment(Assignment::AddAssign) => "Adds a value to a variable.",
198 Operator::Assignment(Assignment::SubtractAssign) => "Subtracts a value from a variable.",
199 Operator::Assignment(Assignment::MultiplyAssign) => "Multiplies a variable by a value.",
200 Operator::Assignment(Assignment::DivideAssign) => "Divides a variable by a value.",
201 Operator::Assignment(Assignment::ConcatenateAssign) => {
202 "Concatenates a list, a string, or a binary value to a variable of the same type."
203 }
204 }
205}
206
207#[cfg(test)]
208mod test {
209 #[test]
210 fn test_examples() {
211 use super::HelpOperators;
212 use crate::test_examples;
213 test_examples(HelpOperators {})
214 }
215}