mirror of
https://github.com/nushell/nushell.git
synced 2025-05-12 02:42:59 +00:00
bcdb9bf5b4
# Description
<!--
_(Thank you for improving Nushell. Please, check our [contributing
guide](../CONTRIBUTING.md) and talk to the core team before making major
changes.)_
_(Description of your pull request goes here. **Provide examples and/or
screenshots** if your changes affect the user experience.)_
-->
Recently a few things changed, which now create issues:
- `1.0.0`, `+500`, and `0x000000` used to get parsed as string, but now
just errors
- `each { print $in }` -> `each {|| print $in }`
I looked through all the help pages and fixed every highlighted (red
background) error: `help commands | each {|i| help $i.name} | table |
less`
# User-Facing Changes
<!--
_(List of all changes that impact the user experience here. This helps
us keep track of breaking changes.)_
-->
The examples work again and no longer contain error syntax-highlighting
# Tests + Formatting
<!--
Don't forget to add tests that cover your changes.
Make sure you've run and fixed any issues with these commands:
- `cargo fmt --all -- --check` to check standard code formatting (`cargo
fmt --all` applies these changes)
- `cargo clippy --workspace -- -D warnings -D clippy::unwrap_used -A
clippy::needless_collect` to check that you're using the standard code
style
- `cargo test --workspace` to check that all tests pass
- `cargo run -- crates/nu-utils/standard_library/tests.nu` to run the
tests for the standard library
> **Note**
> from `nushell` you can also use the `toolkit` as follows
> ```bash
> use toolkit.nu # or use an `env_change` hook to activate it
automatically
> toolkit check pr
> ```
-->
# After Submitting
<!--
If your PR had any user-facing changes, update [the
documentation](https://github.com/nushell/nushell.github.io) after the
PR is merged, if necessary. This will help us keep the docs up to date.
-->
195 lines
8.8 KiB
Rust
195 lines
8.8 KiB
Rust
use itertools::Itertools;
|
|
use nu_engine::CallExt;
|
|
use nu_protocol::ast::Call;
|
|
use nu_protocol::engine::{Command, EngineState, Stack};
|
|
use nu_protocol::{
|
|
Category, Example, IntoPipelineData, PipelineData, ShellError, Signature, SyntaxShape, Type,
|
|
Value,
|
|
};
|
|
|
|
#[derive(Clone)]
|
|
pub struct ViewSource;
|
|
|
|
impl Command for ViewSource {
|
|
fn name(&self) -> &str {
|
|
"view source"
|
|
}
|
|
|
|
fn usage(&self) -> &str {
|
|
"View a block, module, or a definition."
|
|
}
|
|
|
|
fn signature(&self) -> nu_protocol::Signature {
|
|
Signature::build("view source")
|
|
.input_output_types(vec![(Type::Nothing, Type::String)])
|
|
.required("item", SyntaxShape::Any, "name or block to view")
|
|
.category(Category::Debug)
|
|
}
|
|
|
|
fn run(
|
|
&self,
|
|
engine_state: &EngineState,
|
|
stack: &mut Stack,
|
|
call: &Call,
|
|
_input: PipelineData,
|
|
) -> Result<PipelineData, ShellError> {
|
|
let arg: Value = call.req(engine_state, stack, 0)?;
|
|
let arg_span = arg.span()?;
|
|
|
|
match arg {
|
|
Value::Block { val: block_id, .. } | Value::Closure { val: block_id, .. } => {
|
|
let block = engine_state.get_block(block_id);
|
|
|
|
if let Some(span) = block.span {
|
|
let contents = engine_state.get_span_contents(&span);
|
|
Ok(Value::string(String::from_utf8_lossy(contents), call.head)
|
|
.into_pipeline_data())
|
|
} else {
|
|
Ok(Value::string("<internal command>", call.head).into_pipeline_data())
|
|
}
|
|
}
|
|
Value::String { val, .. } => {
|
|
if let Some(decl_id) = engine_state.find_decl(val.as_bytes(), &[]) {
|
|
// arg is a command
|
|
let decl = engine_state.get_decl(decl_id);
|
|
let sig = decl.signature();
|
|
let vec_of_required = &sig.required_positional;
|
|
let vec_of_optional = &sig.optional_positional;
|
|
let vec_of_flags = &sig.named;
|
|
// gets vector of positionals.
|
|
if let Some(block_id) = decl.get_block_id() {
|
|
let block = engine_state.get_block(block_id);
|
|
if let Some(block_span) = block.span {
|
|
let contents = engine_state.get_span_contents(&block_span);
|
|
let mut final_contents = String::from("def ");
|
|
final_contents.push_str(&val);
|
|
// The name of the function...
|
|
final_contents.push_str(" [ ");
|
|
for n in vec_of_required {
|
|
final_contents.push_str(&n.name);
|
|
// name of positional arg
|
|
final_contents.push(':');
|
|
final_contents.push_str(&n.shape.to_string());
|
|
final_contents.push(' ');
|
|
}
|
|
for n in vec_of_optional {
|
|
final_contents.push_str(&n.name);
|
|
// name of positional arg
|
|
final_contents.push_str("?:");
|
|
final_contents.push_str(&n.shape.to_string());
|
|
final_contents.push(' ');
|
|
}
|
|
for n in vec_of_flags {
|
|
final_contents.push_str("--");
|
|
final_contents.push_str(&n.long);
|
|
final_contents.push(' ');
|
|
if n.short.is_some() {
|
|
final_contents.push_str("(-");
|
|
final_contents.push(n.short.expect("this cannot trigger."));
|
|
final_contents.push(')');
|
|
}
|
|
if n.arg.is_some() {
|
|
final_contents.push_str(": ");
|
|
final_contents.push_str(
|
|
&n.arg.as_ref().expect("this cannot trigger.").to_string(),
|
|
);
|
|
}
|
|
final_contents.push(' ');
|
|
}
|
|
final_contents.push_str("] ");
|
|
final_contents.push_str(&String::from_utf8_lossy(contents));
|
|
Ok(Value::string(final_contents, call.head).into_pipeline_data())
|
|
} else {
|
|
Err(ShellError::GenericError(
|
|
"Cannot view value".to_string(),
|
|
"the command does not have a viewable block".to_string(),
|
|
Some(arg_span),
|
|
None,
|
|
Vec::new(),
|
|
))
|
|
}
|
|
} else {
|
|
Err(ShellError::GenericError(
|
|
"Cannot view value".to_string(),
|
|
"the command does not have a viewable block".to_string(),
|
|
Some(arg_span),
|
|
None,
|
|
Vec::new(),
|
|
))
|
|
}
|
|
} else if let Some(module_id) = engine_state.find_module(val.as_bytes(), &[]) {
|
|
// arg is a module
|
|
let module = engine_state.get_module(module_id);
|
|
if let Some(module_span) = module.span {
|
|
let contents = engine_state.get_span_contents(&module_span);
|
|
Ok(Value::string(String::from_utf8_lossy(contents), call.head)
|
|
.into_pipeline_data())
|
|
} else {
|
|
Err(ShellError::GenericError(
|
|
"Cannot view value".to_string(),
|
|
"the module does not have a viewable block".to_string(),
|
|
Some(arg_span),
|
|
None,
|
|
Vec::new(),
|
|
))
|
|
}
|
|
} else if let Some(alias_id) = engine_state.find_alias(val.as_bytes(), &[]) {
|
|
let contents = &mut engine_state.get_alias(alias_id).iter().map(|span| {
|
|
String::from_utf8_lossy(engine_state.get_span_contents(span)).to_string()
|
|
});
|
|
Ok(Value::String {
|
|
val: contents.join(" "),
|
|
span: call.head,
|
|
}
|
|
.into_pipeline_data())
|
|
} else {
|
|
Err(ShellError::GenericError(
|
|
"Cannot view value".to_string(),
|
|
"this name does not correspond to a viewable value".to_string(),
|
|
Some(arg_span),
|
|
None,
|
|
Vec::new(),
|
|
))
|
|
}
|
|
}
|
|
_ => Err(ShellError::GenericError(
|
|
"Cannot view value".to_string(),
|
|
"this value cannot be viewed".to_string(),
|
|
Some(arg_span),
|
|
None,
|
|
Vec::new(),
|
|
)),
|
|
}
|
|
}
|
|
|
|
fn examples(&self) -> Vec<Example> {
|
|
vec![
|
|
Example {
|
|
description: "View the source of a code block",
|
|
example: r#"let abc = {|| echo 'hi' }; view source $abc"#,
|
|
result: Some(Value::test_string("{ echo 'hi' }")),
|
|
},
|
|
Example {
|
|
description: "View the source of a custom command",
|
|
example: r#"def hi [] { echo 'Hi!' }; view source hi"#,
|
|
result: Some(Value::test_string("{ echo 'Hi!' }")),
|
|
},
|
|
Example {
|
|
description: "View the source of a custom command, which participates in the caller environment",
|
|
example: r#"def-env foo [] { let-env BAR = 'BAZ' }; view source foo"#,
|
|
result: Some(Value::test_string("{ let-env BAR = 'BAZ' }")),
|
|
},
|
|
Example {
|
|
description: "View the source of a module",
|
|
example: r#"module mod-foo { export-env { let-env FOO_ENV = 'BAZ' } }; view source mod-foo"#,
|
|
result: Some(Value::test_string(" export-env { let-env FOO_ENV = 'BAZ' }")),
|
|
},
|
|
Example {
|
|
description: "View the source of an alias",
|
|
example: r#"alias hello = echo hi; view source hello"#,
|
|
result: Some(Value::test_string("echo hi")),
|
|
},
|
|
]
|
|
}
|
|
}
|