holm/nushell
1
1
Fork 0
forked from extern/nushell
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Refactor Fetch command (No logic changes) (#2131)

Browse Source 
* Refactoring unrelated to Streaming...

Mainly keeping code DRY

* Remove cli as dependency
This commit is contained in:
Arash Outadi 2020-07-08 09:49:27 -07:00 committed by GitHub
parent b004236927
commit ed6f337a48
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
2 changed files with 75 additions and 128 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

199
crates/nu_plugin_fetch/src/fetch.rs
View File

@ -56,7 +56,7 @@ impl Fetch {
} }
} }
pub async fn fetch_helper( pub async fn fetch(
path: &Value, path: &Value,
has_raw: bool, has_raw: bool,
user: Option<String>, user: Option<String>,
@ -65,12 +65,12 @@ pub async fn fetch_helper(
let path_str = path.as_string()?; let path_str = path.as_string()?;
let path_span = path.tag.span; let path_span = path.tag.span;
let result = fetch(&path_str, path_span, has_raw, user, password).await; let result = helper(&path_str, path_span, has_raw, user, password).await;
if let Err(e) = result { if let Err(e) = result {
return Err(e); return Err(e);
} }
let (file_extension, contents, contents_tag) = result?; let (file_extension, value) = result?;
let file_extension = if has_raw { let file_extension = if has_raw {
None None
@ -80,32 +80,32 @@ pub async fn fetch_helper(
file_extension.or_else(|| path_str.split('.').last().map(String::from)) file_extension.or_else(|| path_str.split('.').last().map(String::from))
}; };
let tagged_contents = contents.retag(&contents_tag);
if let Some(extension) = file_extension { if let Some(extension) = file_extension {
Ok(ReturnSuccess::Action(CommandAction::AutoConvert( Ok(ReturnSuccess::Action(CommandAction::AutoConvert(
tagged_contents, value, extension,
extension,
))) )))
} else { } else {
ReturnSuccess::value(tagged_contents) ReturnSuccess::value(value)
} }
} }
pub async fn fetch( // Helper function that actually goes to retrieve the resource from the url given
// The Option<String> return a possible file extension which can be used in AutoConvert commands
async fn helper(
location: &str, location: &str,
span: Span, span: Span,
has_raw: bool, has_raw: bool,
user: Option<String>, user: Option<String>,
password: Option<String>, password: Option<String>,
) -> Result<(Option<String>, UntaggedValue, Tag), ShellError> { ) -> Result<(Option<String>, Value), ShellError> {
if url::Url::parse(location).is_err() { if let Err(e) = url::Url::parse(location) {
return Err(ShellError::labeled_error( return Err(ShellError::labeled_error(
"Incomplete or incorrect url", format!("Incomplete or incorrect url:\n{:?}", e),
"expected a full url", "expected a full url",
span, span,
)); ));
} }
let login = match (user, password) { let login = match (user, password) {
(Some(user), Some(password)) => Some(encode(&format!("{}:{}", user, password))), (Some(user), Some(password)) => Some(encode(&format!("{}:{}", user, password))),
(Some(user), _) => Some(encode(&format!("{}:", user))), (Some(user), _) => Some(encode(&format!("{}:", user))),
@ -115,6 +115,17 @@ pub async fn fetch(
if let Some(login) = login { if let Some(login) = login {
response = response.set_header("Authorization", format!("Basic {}", login)); response = response.set_header("Authorization", format!("Basic {}", login));
} }
let generate_error = |t: &str, e: Box<dyn std::error::Error>, span: &Span| {
ShellError::labeled_error(
format!("Could not load {} from remote url: {:?}", t, e),
"could not load",
span,
)
};
let tag = Tag {
span,
anchor: Some(AnchorLocation::Url(location.to_string())),
};
match response.await { match response.await {
Ok(mut r) => match r.headers().get("content-type") { Ok(mut r) => match r.headers().get("content-type") {
Some(content_type) => { Some(content_type) => {
@ -128,93 +139,56 @@ pub async fn fetch(
match (content_type.type_(), content_type.subtype()) { match (content_type.type_(), content_type.subtype()) {
(mime::APPLICATION, mime::XML) => Ok(( (mime::APPLICATION, mime::XML) => Ok((
Some("xml".to_string()), Some("xml".to_string()),
UntaggedValue::string(r.body_string().await.map_err(|_| { UntaggedValue::string(
ShellError::labeled_error( r.body_string()
"Could not load text from remote url", .await
"could not load", .map_err(|e| generate_error("text", e, &span))?,
span, )
) .into_value(tag),
})?),
Tag {
span,
anchor: Some(AnchorLocation::Url(location.to_string())),
},
)), )),
(mime::APPLICATION, mime::JSON) => Ok(( (mime::APPLICATION, mime::JSON) => Ok((
Some("json".to_string()), Some("json".to_string()),
UntaggedValue::string(r.body_string().await.map_err(|_| { UntaggedValue::string(
ShellError::labeled_error( r.body_string()
"Could not load text from remote url", .await
"could not load", .map_err(|e| generate_error("text", e, &span))?,
span, )
) .into_value(tag),
})?),
Tag {
span,
anchor: Some(AnchorLocation::Url(location.to_string())),
},
)), )),
(mime::APPLICATION, mime::OCTET_STREAM) => { (mime::APPLICATION, mime::OCTET_STREAM) => {
let buf: Vec<u8> = r.body_bytes().await.map_err(|_| { let buf: Vec<u8> = r
ShellError::labeled_error( .body_bytes()
"Could not load binary file", .await
"could not load", .map_err(|e| generate_error("binary", Box::new(e), &span))?;
span, Ok((None, UntaggedValue::binary(buf).into_value(tag)))
)
})?;
Ok((
None,
UntaggedValue::binary(buf),
Tag {
span,
anchor: Some(AnchorLocation::Url(location.to_string())),
},
))
} }
(mime::IMAGE, mime::SVG) => Ok(( (mime::IMAGE, mime::SVG) => Ok((
Some("svg".to_string()), Some("svg".to_string()),
UntaggedValue::string(r.body_string().await.map_err(|_| { UntaggedValue::string(
ShellError::labeled_error( r.body_string()
"Could not load svg from remote url", .await
"could not load", .map_err(|e| generate_error("svg", e, &span))?,
span, )
) .into_value(tag),
})?),
Tag {
span,
anchor: Some(AnchorLocation::Url(location.to_string())),
},
)), )),
(mime::IMAGE, image_ty) => { (mime::IMAGE, image_ty) => {
let buf: Vec<u8> = r.body_bytes().await.map_err(|_| { let buf: Vec<u8> = r
ShellError::labeled_error( .body_bytes()
"Could not load image file", .await
"could not load", .map_err(|e| generate_error("image", Box::new(e), &span))?;
span,
)
})?;
Ok(( Ok((
Some(image_ty.to_string()), Some(image_ty.to_string()),
UntaggedValue::binary(buf), UntaggedValue::binary(buf).into_value(tag),
Tag {
span,
anchor: Some(AnchorLocation::Url(location.to_string())),
},
)) ))
} }
(mime::TEXT, mime::HTML) => Ok(( (mime::TEXT, mime::HTML) => Ok((
Some("html".to_string()), Some("html".to_string()),
UntaggedValue::string(r.body_string().await.map_err(|_| { UntaggedValue::string(
ShellError::labeled_error( r.body_string()
"Could not load text from remote url", .await
"could not load", .map_err(|e| generate_error("text", e, &span))?,
span, )
) .into_value(tag),
})?),
Tag {
span,
anchor: Some(AnchorLocation::Url(location.to_string())),
},
)), )),
(mime::TEXT, mime::PLAIN) => { (mime::TEXT, mime::PLAIN) => {
let path_extension = url::Url::parse(location) let path_extension = url::Url::parse(location)
@ -236,17 +210,12 @@ pub async fn fetch(
Ok(( Ok((
path_extension, path_extension,
UntaggedValue::string(r.body_string().await.map_err(|_| { UntaggedValue::string(
ShellError::labeled_error( r.body_string()
"Could not load text from remote url", .await
"could not load", .map_err(|e| generate_error("text", e, &span))?,
span, )
) .into_value(tag),
})?),
Tag {
span,
anchor: Some(AnchorLocation::Url(location.to_string())),
},
)) ))
} }
(_ty, _sub_ty) if has_raw => { (_ty, _sub_ty) if has_raw => {
@ -255,44 +224,22 @@ pub async fn fetch(
// For unsupported MIME types, we do not know if the data is UTF-8, // For unsupported MIME types, we do not know if the data is UTF-8,
// so we get the raw body bytes and try to convert to UTF-8 if possible. // so we get the raw body bytes and try to convert to UTF-8 if possible.
match std::str::from_utf8(&raw_bytes) { match std::str::from_utf8(&raw_bytes) {
Ok(response_str) => Ok(( Ok(response_str) => {
None, Ok((None, UntaggedValue::string(response_str).into_value(tag)))
UntaggedValue::string(response_str), }
Tag { Err(_) => Ok((None, UntaggedValue::binary(raw_bytes).into_value(tag))),
span,
anchor: Some(AnchorLocation::Url(location.to_string())),
},
)),
Err(_) => Ok((
None,
UntaggedValue::binary(raw_bytes),
Tag {
span,
anchor: Some(AnchorLocation::Url(location.to_string())),
},
)),
} }
} }
(ty, sub_ty) => Ok(( (ty, sub_ty) => Err(ShellError::unimplemented(format!(
None, "Not yet supported MIME type: {} {}",
UntaggedValue::string(format!( ty, sub_ty
"Not yet supported MIME type: {} {}", ))),
ty, sub_ty
)),
Tag {
span,
anchor: Some(AnchorLocation::Url(location.to_string())),
},
)),
} }
} }
// TODO: Should this return "nothing" or Err?
None => Ok(( None => Ok((
None, None,
UntaggedValue::string("No content type found".to_owned()), UntaggedValue::string("No content type found".to_owned()).into_value(tag),
Tag {
span,
anchor: Some(AnchorLocation::Url(location.to_string())),
},
)), )),
}, },
Err(_) => Err(ShellError::labeled_error( Err(_) => Err(ShellError::labeled_error(

4
crates/nu_plugin_fetch/src/nu/mod.rs
View File

@ -3,7 +3,7 @@ use nu_errors::ShellError;
use nu_plugin::Plugin; use nu_plugin::Plugin;
use nu_protocol::{CallInfo, ReturnValue, Signature, SyntaxShape}; use nu_protocol::{CallInfo, ReturnValue, Signature, SyntaxShape};
use crate::fetch::fetch_helper; use crate::fetch::fetch;
use crate::Fetch; use crate::Fetch;
impl Plugin for Fetch { impl Plugin for Fetch {
@ -33,7 +33,7 @@ impl Plugin for Fetch {
fn begin_filter(&mut self, callinfo: CallInfo) -> Result<Vec<ReturnValue>, ShellError> { fn begin_filter(&mut self, callinfo: CallInfo) -> Result<Vec<ReturnValue>, ShellError> {
self.setup(callinfo)?; self.setup(callinfo)?;
Ok(vec![block_on(fetch_helper( Ok(vec![block_on(fetch(
&self.path.clone().ok_or_else(|| { &self.path.clone().ok_or_else(|| {
ShellError::labeled_error("internal error: path not set", "path not set", &self.tag) ShellError::labeled_error("internal error: path not set", "path not set", &self.tag)
})?, })?,