nushell/crates/nu-command/src/network/url/parse.rs
Stefan Holderbach 4b301710d3
Convert more examples and tests to record! macro (#10840)
# 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.
2023-10-28 14:52:31 +02:00

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 {})
}
}