Add artifacts_download module and example for universal packages

autorust/codegen/src/autorust_toml.rs

@@ -116,7 +116,8 @@ impl<'a> PackageConfig {
             let deny: HashSet<&str> = self.tags.deny.iter().map(String::as_str).collect();
             tags.retain(|tag| !deny.contains(tag.name()));
         }
-        let mut deny_contains: Vec<&str> = self.tags.deny_contains.iter().map(String::as_str).collect();
+        let mut deny_contains: Vec<&str> =
+            self.tags.deny_contains.iter().map(String::as_str).collect();
         if self.tags.deny_contains_preview.unwrap_or_default() {
             deny_contains.push("preview");
         }
@@ -325,7 +326,10 @@ mod tests {
             default = "package-resources-2021-04"
             "#,
         )?;
-        assert_eq!(Some("package-resources-2021-04".to_string()), config.tags.default);
+        assert_eq!(
+            Some("package-resources-2021-04".to_string()),
+            config.tags.default
+        );
         Ok(())
     }
 

autorust/codegen/src/cargo_toml.rs

@@ -2,7 +2,13 @@ use crate::Result;
 use crate::{config_parser::Tag, jinja::CargoToml};
 use camino::Utf8Path;
 
-pub fn create(package_name: &str, tags: &[&Tag], default_tag: &Tag, has_xml: bool, path: &Utf8Path) -> Result<()> {
+pub fn create(
+    package_name: &str,
+    tags: &[&Tag],
+    default_tag: &Tag,
+    has_xml: bool,
+    path: &Utf8Path,
+) -> Result<()> {
     let default_tag = &default_tag.rust_feature_name();
 
     // https://docs.rs/about/metadata
@@ -22,7 +28,9 @@ pub fn create(package_name: &str, tags: &[&Tag], default_tag: &Tag, has_xml: boo
 
 pub fn get_default_tag<'a>(tags: &[&'a Tag], default_tag: Option<&str>) -> &'a Tag {
     let default_tag = tags.iter().find(|tag| Some(tag.name()) == default_tag);
-    let is_preview = default_tag.map(|tag| tag.name().contains("preview")).unwrap_or_default();
+    let is_preview = default_tag
+        .map(|tag| tag.name().contains("preview"))
+        .unwrap_or_default();
     let stable_tag = tags.iter().find(|tag| !tag.name().contains("preview"));
     match (default_tag, is_preview, stable_tag) {
         (Some(default_tag), false, _) => default_tag,
@@ -94,13 +102,20 @@ mod tests {
         ];
         let tags: Vec<_> = tags.into_iter().map(Tag::new).collect();
         let tags: Vec<_> = tags.iter().collect();
-        assert_eq!("package-2020-04", get_default_tag(&tags, Some("package-2020-04")).name());
+        assert_eq!(
+            "package-2020-04",
+            get_default_tag(&tags, Some("package-2020-04")).name()
+        );
         Ok(())
     }
 
     #[test]
     fn specified_preview() -> Result<()> {
-        let tags = vec!["package-preview-2022-05", "package-2019-06-preview", "package-2019-04-preview"];
+        let tags = vec![
+            "package-preview-2022-05",
+            "package-2019-06-preview",
+            "package-2019-04-preview",
+        ];
         let tags: Vec<_> = tags.into_iter().map(Tag::new).collect();
         let tags: Vec<_> = tags.iter().collect();
         assert_eq!(

autorust/codegen/src/codegen_operations/function_code.rs

@@ -17,7 +17,11 @@ pub(crate) struct ClientFunctionCode {
 }
 
 impl ClientFunctionCode {
-    pub fn new(operation: &WebOperationGen, parameters: &FunctionParams, in_operation_group: bool) -> Result<Self> {
+    pub fn new(
+        operation: &WebOperationGen,
+        parameters: &FunctionParams,
+        in_operation_group: bool,
+    ) -> Result<Self> {
         let fname = operation.function_name()?;
         let summary = operation.0.summary.clone();
         let description = operation.0.description.clone();
@@ -41,7 +45,9 @@ impl ToTokens for ClientFunctionCode {
         }
         for param in self.parameters.required_params() {
             let FunctionParam {
-                variable_name, type_name, ..
+                variable_name,
+                type_name,
+                ..
             } = param;
             let mut type_name = type_name.clone();
             let is_vec = type_name.is_vec();
@@ -54,7 +60,9 @@ impl ToTokens for ClientFunctionCode {
         }
         for param in self.parameters.optional_params() {
             let FunctionParam {
-                variable_name, type_name, ..
+                variable_name,
+                type_name,
+                ..
             } = param;
             if type_name.is_vec() {
                 params.push(quote! { #variable_name: Vec::new() });

autorust/codegen/src/codegen_operations/operation_module.rs

@@ -2,8 +2,10 @@ use proc_macro2::{Ident, TokenStream};
 use quote::{quote, ToTokens};
 
 use super::{
-    request_builder_into_future::RequestBuilderIntoFutureCode, request_builder_send::RequestBuilderSendCode,
-    request_builder_setter::RequestBuilderSettersCode, request_builder_struct::RequestBuilderStructCode, response_code::ResponseCode,
+    request_builder_into_future::RequestBuilderIntoFutureCode,
+    request_builder_send::RequestBuilderSendCode,
+    request_builder_setter::RequestBuilderSettersCode,
+    request_builder_struct::RequestBuilderStructCode, response_code::ResponseCode,
 };
 pub struct OperationModuleCode {
     pub module_name: Ident,

autorust/codegen/src/codegen_operations/operations.rs

@@ -34,24 +34,36 @@ impl OperationCode {
         // get the content-types from the operation, else the spec, else default to json
         let consumes = operation
             .pick_consumes()
-            .unwrap_or_else(|| cg.spec.pick_consumes().unwrap_or(content_type::APPLICATION_JSON))
+            .unwrap_or_else(|| {
+                cg.spec
+                    .pick_consumes()
+                    .unwrap_or(content_type::APPLICATION_JSON)
+            })
             .to_string();
         let produces = operation
             .pick_produces()
-            .unwrap_or_else(|| cg.spec.pick_produces().unwrap_or(content_type::APPLICATION_JSON))
+            .unwrap_or_else(|| {
+                cg.spec
+                    .pick_produces()
+                    .unwrap_or(content_type::APPLICATION_JSON)
+            })
             .to_string();
 
         let lro = operation.0.long_running_operation;
         let lro_options = operation.0.long_running_operation_options.clone();
 
         let request_builder = SetRequestCode::new(operation, parameters, consumes);
         let in_operation_group = operation.0.in_group();
-        let client_function_code = ClientFunctionCode::new(operation, parameters, in_operation_group)?;
-        let request_builder_struct_code = RequestBuilderStructCode::new(parameters, in_operation_group, lro, lro_options.clone());
+        let client_function_code =
+            ClientFunctionCode::new(operation, parameters, in_operation_group)?;
+        let request_builder_struct_code =
+            RequestBuilderStructCode::new(parameters, in_operation_group, lro, lro_options.clone());
         let request_builder_setters_code = RequestBuilderSettersCode::new(parameters);
         let response_code = ResponseCode::new(cg, operation, produces)?;
-        let request_builder_send_code = RequestBuilderSendCode::new(new_request_code, request_builder, response_code.clone())?;
-        let request_builder_intofuture_code = RequestBuilderIntoFutureCode::new(response_code.clone(), lro, lro_options)?;
+        let request_builder_send_code =
+            RequestBuilderSendCode::new(new_request_code, request_builder, response_code.clone())?;
+        let request_builder_intofuture_code =
+            RequestBuilderIntoFutureCode::new(response_code.clone(), lro, lro_options)?;
 
         let module_code = OperationModuleCode {
             module_name: operation.function_name()?,

autorust/codegen/src/codegen_operations/request_builder_send.rs

@@ -6,7 +6,9 @@ use crate::codegen::PARAM_RE;
 use crate::Result;
 use crate::{codegen::parse_path_params, identifier::SnakeCaseIdent};
 
-use super::{new_request_code::NewRequestCode, response_code::ResponseCode, set_request_code::SetRequestCode};
+use super::{
+    new_request_code::NewRequestCode, response_code::ResponseCode, set_request_code::SetRequestCode,
+};
 /// The `send` function of the request builder.
 pub struct RequestBuilderSendCode {
     new_request_code: NewRequestCode,
@@ -16,7 +18,11 @@ pub struct RequestBuilderSendCode {
 }
 
 impl RequestBuilderSendCode {
-    pub fn new(new_request_code: NewRequestCode, request_builder: SetRequestCode, response_code: ResponseCode) -> Result<Self> {
+    pub fn new(
+        new_request_code: NewRequestCode,
+        request_builder: SetRequestCode,
+        response_code: ResponseCode,
+    ) -> Result<Self> {
         let params = parse_path_params(&new_request_code.path);
         let url_args: Result<Vec<_>> = params.iter().map(|s| s.to_snake_case_ident()).collect();
         let url_args = url_args?;
@@ -121,12 +127,17 @@ impl ToTokens for RequestBuilderSendCode {
                         req.insert_header(azure_core::headers::VERSION, #api_version);
                     });
                 }
-                let response_type = self.response_code.response_type().expect("pageable response has a body");
+                let response_type = self
+                    .response_code
+                    .response_type()
+                    .expect("pageable response has a body");
 
                 // some of the pageable requests specify the continuation token
                 // as a parameter.  In this case, use the basic request builder,
                 // but insert the continuation parameter
-                if let Some(continuable_param) = get_continuable_param(next_link_name, request_builder) {
+                if let Some(continuable_param) =
+                    get_continuable_param(next_link_name, request_builder)
+                {
                     quote! {
                         pub fn into_stream(self) -> azure_core::Pageable<#response_type, azure_core::error::Error> {
                             let make_request = move |continuation: Option<String>| {

autorust/codegen/src/codegen_operations/request_builder_setter.rs

@@ -21,7 +21,9 @@ impl ToTokens for RequestBuilderSettersCode {
     fn to_tokens(&self, tokens: &mut TokenStream) {
         for param in self.parameters.optional_params() {
             let FunctionParam {
-                variable_name, type_name, ..
+                variable_name,
+                type_name,
+                ..
             } = param;
             let is_vec = type_name.is_vec();
             let mut type_name = type_name.clone();

autorust/codegen/src/codegen_operations/set_request_code.rs

@@ -3,7 +3,10 @@ use quote::{quote, ToTokens};
 
 use crate::spec::WebVerb;
 
-use super::{function_params::FunctionParams, set_request_param_code::SetRequestParamsCode, web_operation_gen::WebOperationGen};
+use super::{
+    function_params::FunctionParams, set_request_param_code::SetRequestParamsCode,
+    web_operation_gen::WebOperationGen,
+};
 /// Set all body and parameters for the request.
 pub struct SetRequestCode {
     pub has_param_api_version: bool,

autorust/codegen/src/codegen_operations/set_request_param_code.rs

@@ -111,7 +111,9 @@ impl ToTokens for SetRequestParamsCode {
 
                     // TODO: more work needs to be done to ensure we're using
                     // the right encoder.
-                    let encoder = if !self.params.has_content_type_header() && self.content_type.starts_with("application/xml") {
+                    let encoder = if !self.params.has_content_type_header()
+                        && self.content_type.starts_with("application/xml")
+                    {
                         quote! {azure_core::xml::to_xml}
                     } else {
                         quote! { azure_core::to_json }

autorust/codegen/src/codegen_operations/web_operation_gen.rs

@@ -143,7 +143,10 @@ pub struct Pageable {
 /// Creating a function name from the path and verb when an operationId is not specified.
 /// All azure-rest-api-specs operations should have an operationId.
 fn create_function_name(verb: &WebVerb, path: &str) -> String {
-    let mut path = path.split('/').filter(|&x| !x.is_empty()).collect::<Vec<_>>();
+    let mut path = path
+        .split('/')
+        .filter(|&x| !x.is_empty())
+        .collect::<Vec<_>>();
     path.insert(0, verb.as_str());
     path.join("_")
 }
@@ -165,7 +168,10 @@ mod tests {
             verb: WebVerb::Get,
             ..Default::default()
         });
-        assert_eq!(Some("private_clouds".to_owned()), operation.rust_module_name());
+        assert_eq!(
+            Some("private_clouds".to_owned()),
+            operation.rust_module_name()
+        );
         assert_eq!("create_or_update", operation.rust_function_name());
     }