forked from extern/nushell
4c787af26d
# Description Now that we've landed the debug commands we were working on, let's relocate them to an easier place to find all of them. That's what this PR does. The only actual code change was changing the `timeit` command to a `Category::Debug` command. The rest is just moving things around and hooking them up. # User-Facing Changes # 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 # 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")),
|
|
},
|
|
]
|
|
}
|
|
}
|