# Description Use `record!` macro instead of defining two separate `vec!` for `cols` and `vals` when appropriate. This visually aligns the key with the value. Further more you don't have to deal with the construction of `Record { cols, vals }` so we can hide the implementation details in the future. ## State Not covering all possible commands yet, also some tests/examples are better expressed by creating cols and vals separately. # User/Developer-Facing Changes The examples and tests should read more natural. No relevant functional change # Bycatch Where I noticed it I replaced usage of `Value` constructors with `Span::test_data()` or `Span::unknown()` to the `Value::test_...` constructors. This should make things more readable and also simplify changes to the `Span` system in the future.
145 lines
4.9 KiB
Rust
145 lines
4.9 KiB
Rust
use super::url;
|
|
use nu_protocol::ast::Call;
|
|
use nu_protocol::engine::{Command, EngineState, Stack};
|
|
use nu_protocol::{
|
|
record, Category, Example, PipelineData, ShellError, Signature, Span, SyntaxShape, Type, Value,
|
|
};
|
|
|
|
use url::Url;
|
|
|
|
#[derive(Clone)]
|
|
pub struct SubCommand;
|
|
|
|
impl Command for SubCommand {
|
|
fn name(&self) -> &str {
|
|
"url parse"
|
|
}
|
|
|
|
fn signature(&self) -> Signature {
|
|
Signature::build("url parse")
|
|
.input_output_types(vec![
|
|
(Type::String, Type::Record(vec![])),
|
|
(Type::Table(vec![]), Type::Table(vec![])),
|
|
(Type::Record(vec![]), Type::Record(vec![])),
|
|
])
|
|
.allow_variants_without_examples(true)
|
|
.rest(
|
|
"rest",
|
|
SyntaxShape::CellPath,
|
|
"optionally operate by cell path",
|
|
)
|
|
.category(Category::Network)
|
|
}
|
|
|
|
fn usage(&self) -> &str {
|
|
"Parses a url."
|
|
}
|
|
|
|
fn search_terms(&self) -> Vec<&str> {
|
|
vec![
|
|
"scheme", "username", "password", "hostname", "port", "path", "query", "fragment",
|
|
]
|
|
}
|
|
|
|
fn run(
|
|
&self,
|
|
engine_state: &EngineState,
|
|
_: &mut Stack,
|
|
call: &Call,
|
|
input: PipelineData,
|
|
) -> Result<PipelineData, ShellError> {
|
|
parse(input.into_value(call.head), call.head, engine_state)
|
|
}
|
|
|
|
fn examples(&self) -> Vec<Example> {
|
|
vec![Example {
|
|
description: "Parses a url",
|
|
example: "'http://user123:pass567@www.example.com:8081/foo/bar?param1=section&p2=&f[name]=vldc#hello' | url parse",
|
|
result: Some(Value::test_record(record! {
|
|
"scheme" => Value::test_string("http"),
|
|
"username" => Value::test_string("user123"),
|
|
"password" => Value::test_string("pass567"),
|
|
"host" => Value::test_string("www.example.com"),
|
|
"port" => Value::test_string("8081"),
|
|
"path" => Value::test_string("/foo/bar"),
|
|
"query" => Value::test_string("param1=section&p2=&f[name]=vldc"),
|
|
"fragment" => Value::test_string("hello"),
|
|
"params" => Value::test_record(record! {
|
|
"param1" => Value::test_string("section"),
|
|
"p2" => Value::test_string(""),
|
|
"f[name]" => Value::test_string("vldc"),
|
|
}),
|
|
})),
|
|
}]
|
|
}
|
|
}
|
|
|
|
fn get_url_string(value: &Value, engine_state: &EngineState) -> String {
|
|
value.into_string("", engine_state.get_config())
|
|
}
|
|
|
|
fn parse(value: Value, head: Span, engine_state: &EngineState) -> Result<PipelineData, ShellError> {
|
|
let url_string = get_url_string(&value, engine_state);
|
|
|
|
let result_url = Url::parse(url_string.as_str());
|
|
|
|
// This is the span of the original string, not the call head.
|
|
let span = value.span();
|
|
|
|
match result_url {
|
|
Ok(url) => {
|
|
let params =
|
|
serde_urlencoded::from_str::<Vec<(String, String)>>(url.query().unwrap_or(""));
|
|
match params {
|
|
Ok(result) => {
|
|
let params = result
|
|
.into_iter()
|
|
.map(|(k, v)| (k, Value::string(v, head)))
|
|
.collect();
|
|
|
|
let port = url.port().map(|p| p.to_string()).unwrap_or_default();
|
|
|
|
let record = record! {
|
|
"scheme" => Value::string(url.scheme(), head),
|
|
"username" => Value::string(url.username(), head),
|
|
"password" => Value::string(url.password().unwrap_or(""), head),
|
|
"host" => Value::string(url.host_str().unwrap_or(""), head),
|
|
"port" => Value::string(port, head),
|
|
"path" => Value::string(url.path(), head),
|
|
"query" => Value::string(url.query().unwrap_or(""), head),
|
|
"fragment" => Value::string(url.fragment().unwrap_or(""), head),
|
|
"params" => Value::record(params, head),
|
|
};
|
|
|
|
Ok(PipelineData::Value(Value::record(record, head), None))
|
|
}
|
|
_ => Err(ShellError::UnsupportedInput(
|
|
"String not compatible with url-encoding".to_string(),
|
|
"value originates from here".into(),
|
|
head,
|
|
span,
|
|
)),
|
|
}
|
|
}
|
|
Err(_e) => Err(ShellError::UnsupportedInput(
|
|
"Incomplete or incorrect URL. Expected a full URL, e.g., https://www.example.com"
|
|
.to_string(),
|
|
"value originates from here".into(),
|
|
head,
|
|
span,
|
|
)),
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod test {
|
|
use super::*;
|
|
|
|
#[test]
|
|
fn test_examples() {
|
|
use crate::test_examples;
|
|
|
|
test_examples(SubCommand {})
|
|
}
|
|
}
|