bug fixes to add 4 more azure_svc crates (#505)

Author: ctaggart

services/autorust/codegen/examples/gen_mgmt.rs

@@ -42,6 +42,7 @@ const SKIP_SERVICE_TAGS: &[(&str, &str)] = &[
     ("datamigration", "package-2021-06"),
     ("deploymentmanager", "package-2018-09-01-preview"), //  identifiers are bound more than once in param list.   https://github.com/Azure/azure-sdk-for-rust/issues/415
     ("iothub", "package-preview-2021-07"),               // duplicate tag https://github.com/Azure/azure-rest-api-specs/issues/16692
+    ("iothub", "package-2021-07"),                       // duplicate tag https://github.com/Azure/azure-rest-api-specs/issues/16692
     ("mediaservices", "package-2019-05-preview"), // invalid unicode character of a dash instead of a hyphen https://github.com/Azure/azure-rest-api-specs/pull/11576
     ("marketplace", "package-2020-01-01"),
     ("marketplace", "package-2020-12-01"),

services/autorust/codegen/examples/gen_svc.rs

@@ -8,24 +8,20 @@ const OUTPUT_FOLDER: &str = "../svc";
 const ONLY_SERVICES: &[&str] = &[];
 
 const SKIP_SERVICES: &[&str] = &[
-    "deviceupdate",            // missing field `authorizationUrl`
-    "digitaltwins",            // missing field `scopes`
-    "machinelearningservices", // untagged enum
-    "servicefabric",           // currently generates `async` member names
-    "hdinsight",               // job_id appears multiple times?
+    "machinelearningservices", // need to box inner errors
+    "hdinsight",               // job_id appears multiple times https://github.com/Azure/azure-sdk-for-rust/issues/503
     "videoanalyzer",           // no operations
     "mediaservices",           // no operations
-    "marketplacecatalog",      // BadRequest400 uses models::String?
 ];
 
 const SKIP_SERVICE_TAGS: &[(&str, &str)] = &[
-    ("agrifood", "package-2021-03-31-preview"), // untagged enum?
-    ("attestation", "package-2018-09-01"),      // uses models::String?
-    ("containerregistry", "package-2019-08"),   // untagged enum
-    ("containerregistry", "package-2019-07"),   // untagged enum
-    ("purview", "package-2021-05-01-preview"),  // untagged enum
-    ("maps", "package-preview-2.0"),            // string \"200Async\", expected length 3"
-    ("maps", "package-1.0-preview"),            // "invalid value: string \"201Async\"
+    ("agrifood", "package-2021-03-31-preview"), // duplicate params https://github.com/Azure/azure-sdk-for-rust/issues/501
+    ("purview", "package-2021-05-01-preview"),  // need to box types
+    ("maps", "package-preview-2.0"),            // global responses https://github.com/Azure/azure-sdk-for-rust/issues/502
+    ("maps", "package-1.0-preview"),            // global responses https://github.com/Azure/azure-sdk-for-rust/issues/502
+    ("servicefabric", "6.2"),                   // invalid model TimeBasedBackupScheduleDescription
+    ("servicefabric", "6.3"),                   // invalid model TimeBasedBackupScheduleDescription
+    ("servicefabric", "6.4"),                   // invalid model TimeBasedBackupScheduleDescription
     ("storagedatalake", "package-2018-11"),     // "invalid value: string \"ErrorResponse\", expected length 3"
     ("storagedatalake", "package-2018-06-preview"),
     ("storagedatalake", "package-2019-10"),
@@ -98,7 +94,39 @@ const BOX_PROPERTIES: &[(&str, &str, &str)] = &[
         "../../../azure-rest-api-specs/specification/datalake-analytics/data-plane/Microsoft.DataLakeAnalytics/preview/2017-09-01-preview/job.json",
         "JobInnerError",
         "innerError"
-    )
+    ),
+    // deviceupdate
+    (
+        "../../../azure-rest-api-specs/specification/deviceupdate/data-plane/Microsoft.DeviceUpdate/preview/2020-09-01/deviceupdate.json",
+        "Error",
+        "innerError"
+    ),
+    (
+        "../../../azure-rest-api-specs/specification/deviceupdate/data-plane/Microsoft.DeviceUpdate/preview/2020-09-01/deviceupdate.json",
+        "InnerError",
+        "innerError"
+    ),
+    // digitaltwins
+    (
+        "../../../azure-rest-api-specs/specification/digitaltwins/data-plane/Microsoft.DigitalTwins/preview/2020-05-31-preview/digitaltwins.json",
+        "Error",
+        "innererror"
+    ),
+    (
+        "../../../azure-rest-api-specs/specification/digitaltwins/data-plane/Microsoft.DigitalTwins/preview/2020-05-31-preview/digitaltwins.json",
+        "InnerError",
+        "innererror"
+    ),
+    (
+        "../../../azure-rest-api-specs/specification/digitaltwins/data-plane/Microsoft.DigitalTwins/stable/2020-10-31/digitaltwins.json",
+        "Error",
+        "innererror"
+    ),
+    (
+        "../../../azure-rest-api-specs/specification/digitaltwins/data-plane/Microsoft.DigitalTwins/stable/2020-10-31/digitaltwins.json",
+        "InnerError",
+        "innererror"
+    ),
 ];
 
 pub type Result<T, E = Error> = std::result::Result<T, E>;

services/autorust/codegen/src/codegen_models.rs

@@ -3,11 +3,10 @@ use crate::{
         create_generated_by_header, enum_values_as_strings, get_schema_array_items, get_type_name_for_schema, get_type_name_for_schema_ref,
         is_array, is_basic_type, is_local_enum, is_local_struct, is_vec, require, Error,
     },
-    identifier::{ident, CamelCaseIdent},
+    identifier::{CamelCaseIdent, SnakeCaseIdent},
     spec, CodeGen, PropertyName, ResolvedSchema,
 };
 use autorust_openapi::Reference;
-use heck::{CamelCase, SnakeCase};
 use indexmap::IndexMap;
 use proc_macro2::TokenStream;
 use quote::quote;
@@ -85,7 +84,7 @@ pub fn create_models(cg: &CodeGen) -> Result<TokenStream, Error> {
 }
 
 fn create_basic_type_alias(property_name: &str, property: &ResolvedSchema) -> Result<(TokenStream, TokenStream), Error> {
-    let id = ident(&property_name.to_camel_case()).map_err(Error::StructName)?;
+    let id = property_name.to_camel_case_ident().map_err(Error::StructName)?;
     let value = get_type_name_for_schema(&property.schema.common)?.to_token_stream(false, false)?;
     Ok((id, value))
 }
@@ -117,7 +116,7 @@ fn create_enum(
     lowercase_workaround: bool,
 ) -> Result<(TokenStream, TokenStream), Error> {
     let enum_values = enum_values_as_strings(&property.schema.common.enum_);
-    let id = ident(&property_name.to_camel_case()).map_err(|source| Error::EnumName {
+    let id = &property_name.to_camel_case_ident().map_err(|source| Error::EnumName {
         source,
         property: property_name.to_owned(),
     })?;
@@ -141,7 +140,7 @@ fn create_enum(
         };
         values.extend(value);
     }
-    let nm = ident(&property_name.to_camel_case()).map_err(|source| Error::EnumName {
+    let nm = property_name.to_camel_case_ident().map_err(|source| Error::EnumName {
         source,
         property: property_name.to_owned(),
     })?;
@@ -157,7 +156,7 @@ fn create_enum(
 
 fn create_vec_alias(alias_name: &str, schema: &ResolvedSchema) -> Result<TokenStream, Error> {
     let items = get_schema_array_items(&schema.schema.common)?;
-    let typ = ident(&alias_name.to_camel_case()).map_err(Error::VecAliasName)?;
+    let typ = &alias_name.to_camel_case_ident().map_err(Error::VecAliasName)?;
     let items_typ = get_type_name_for_schema_ref(items)?.to_token_stream(false, false)?;
     Ok(quote! { pub type #typ = Vec<#items_typ>; })
 }
@@ -167,13 +166,13 @@ fn create_struct(cg: &CodeGen, doc_file: &Path, struct_name: &str, schema: &Reso
     let mut streams = Vec::new();
     let mut local_types = Vec::new();
     let mut props = TokenStream::new();
-    let ns = ident(&struct_name.to_snake_case()).map_err(Error::StructName)?;
-    let nm = ident(&struct_name.to_camel_case()).map_err(Error::StructName)?;
+    let ns = struct_name.to_snake_case_ident().map_err(Error::StructName)?;
+    let nm = struct_name.to_camel_case_ident().map_err(Error::StructName)?;
     let required: HashSet<&str> = schema.schema.required.iter().map(String::as_str).collect();
 
     for schema in &schema.schema.all_of {
         let type_name = get_type_name_for_schema_ref(schema)?.to_token_stream(false, false)?;
-        let field_name = ident(&type_name.to_string().to_snake_case()).map_err(Error::StructFieldName)?;
+        let field_name = type_name.to_string().to_snake_case_ident().map_err(Error::StructFieldName)?;
         props.extend(quote! {
             #[serde(flatten)]
             pub #field_name: #type_name,
@@ -182,7 +181,7 @@ fn create_struct(cg: &CodeGen, doc_file: &Path, struct_name: &str, schema: &Reso
 
     let properties = cg.spec.resolve_schema_map(doc_file, &schema.schema.properties)?;
     for (property_name, property) in &properties {
-        let nm = ident(&property_name.to_snake_case()).map_err(Error::StructName)?;
+        let nm = property_name.to_snake_case_ident().map_err(Error::StructName)?;
         let prop_nm = &PropertyName {
             file_path: PathBuf::from(doc_file),
             schema_name: struct_name.to_owned(),
@@ -271,15 +270,15 @@ fn create_struct_field_type(
 ) -> Result<(TokenStream, Vec<TokenStream>), Error> {
     match &property.ref_key {
         Some(ref_key) => {
-            let tp = ident(&ref_key.name.to_camel_case()).map_err(Error::PropertyName)?;
+            let tp = ref_key.name.to_camel_case_ident().map_err(Error::PropertyName)?;
             Ok((tp, Vec::new()))
         }
         None => {
             if is_local_enum(property) {
                 let (tp_name, tp) = create_enum(namespace, property_name, property, lowercase_workaround)?;
                 Ok((tp_name, vec![tp]))
             } else if is_local_struct(property) {
-                let id = ident(&property_name.to_camel_case()).map_err(Error::PropertyName)?;
+                let id = property_name.to_camel_case_ident().map_err(Error::PropertyName)?;
                 let tp_name = quote! {#namespace::#id};
                 let tps = create_struct(cg, doc_file, property_name, property)?;
                 // println!("creating local struct {:?} {}", tp_name, tps.len());

services/autorust/codegen/src/codegen_operations.rs

@@ -2,6 +2,7 @@ use crate::{
     codegen::{create_generated_by_header, get_type_name_for_schema, get_type_name_for_schema_ref, is_array, is_string, require, Error},
     codegen::{parse_params, PARAM_RE},
     identifier::ident,
+    identifier::SnakeCaseIdent,
     spec::{WebOperation, WebVerb},
     status_codes::{get_error_responses, get_response_type_name, get_success_responses, has_default_response},
     status_codes::{get_response_type_ident, get_status_code_ident},
@@ -110,7 +111,7 @@ fn create_function(cg: &CodeGen, operation: &WebOperation) -> Result<TokenStream
 
     let params = parse_params(&operation.path);
     // println!("path params {:#?}", params);
-    let params: Result<Vec<_>, Error> = params.iter().map(|s| ident(&s.to_snake_case()).map_err(Error::ParamName)).collect();
+    let params: Result<Vec<_>, Error> = params.iter().map(|s| s.to_snake_case_ident().map_err(Error::ParamName)).collect();
     let params = params?;
     let url_str_args = quote! { #(#params),* };
 
@@ -281,18 +282,22 @@ fn create_function(cg: &CodeGen, operation: &WebOperation) -> Result<TokenStream
                     });
                 }
             }
-            ParameterType::Form => {
-                if required {
-                    ts_request_builder.extend(quote! {
-                        req_builder = req_builder.form(#param_name_var);
-                    });
-                } else {
-                    ts_request_builder.extend(quote! {
-                        if let Some(#param_name_var) = #param_name_var {
-                            req_builder = req_builder.form(#param_name_var);
-                        }
-                    });
-                }
+            ParameterType::FormData => {
+                ts_request_builder.extend(quote! {
+                    unimplemented!("form data not yet supported");
+                });
+                // https://github.com/Azure/azure-sdk-for-rust/issues/500
+                // if required {
+                //     cargo run --example gen_svc --release
+                //         req_builder = req_builder.form(#param_name_var);
+                //     });
+                // } else {
+                //     ts_request_builder.extend(quote! {
+                //         if let Some(#param_name_var) = #param_name_var {
+                //             req_builder = req_builder.form(#param_name_var);
+                //         }
+                //     });
+                // }
             }
         }
     }
@@ -558,7 +563,7 @@ fn create_function_params(_cg: &CodeGen, _doc_file: &Path, parameters: &[Paramet
 }
 
 fn get_param_name(param: &Parameter) -> Result<TokenStream, Error> {
-    ident(&param.name.to_snake_case()).map_err(Error::ParamName)
+    param.name.to_snake_case_ident().map_err(Error::ParamName)
 }
 
 fn get_param_type(param: &Parameter) -> Result<TokenStream, Error> {

services/autorust/codegen/src/identifier.rs

@@ -1,4 +1,4 @@
-use heck::CamelCase;
+use heck::{CamelCase, SnakeCase};
 use proc_macro2::TokenStream;
 use quote::ToTokens;
 
@@ -15,7 +15,8 @@ pub trait CamelCaseIdent: ToOwned {
 impl CamelCaseIdent for str {
     fn to_camel_case_ident(&self) -> Result<TokenStream, Error> {
         let is_number = starts_with_number(self);
-        let mut txt = replace_first(self, true);
+        let mut txt = replace_first(self, true, true);
+        txt = replace_first(&txt, true, false);
         txt = replace_special_chars(&txt);
         if !is_number {
             // heck::CamelCase::to_camel_case will remove underscores
@@ -29,8 +30,26 @@ impl CamelCaseIdent for str {
     }
 }
 
+pub trait SnakeCaseIdent: ToOwned {
+    fn to_snake_case_ident(&self) -> Result<TokenStream, Error>;
+}
+
+impl SnakeCaseIdent for str {
+    fn to_snake_case_ident(&self) -> Result<TokenStream, Error> {
+        let mut txt = replace_first(self, false, true);
+        txt = replace_special_chars(&txt);
+        txt = txt.to_snake_case();
+        txt = suffix_keyword(&txt);
+        let idt = syn::parse_str::<syn::Ident>(&txt).map_err(|source| Error::ParseIdentError {
+            source,
+            text: self.to_owned(),
+        })?;
+        Ok(idt.into_token_stream())
+    }
+}
+
 pub fn ident(text: &str) -> Result<TokenStream, Error> {
-    let mut txt = replace_first(text, false);
+    let mut txt = replace_first(text, false, false);
     txt = replace_special_chars(&txt);
     txt = remove_spaces(&txt);
     txt = suffix_keyword(&txt);
@@ -52,6 +71,7 @@ fn replace_special_chars(text: &str) -> String {
     txt = txt.replace("-", "_");
     txt = txt.replace("/", "_");
     txt = txt.replace("*", "_");
+    txt = txt.replace(":", "_");
     txt
 }
 
@@ -68,14 +88,18 @@ fn unicode(c: char, uppercase: bool) -> String {
     format!("{}{}", u, &s[3..s.len() - 1])
 }
 
-fn replace_first(text: &str, uppercase: bool) -> String {
+fn replace_first(text: &str, uppercase: bool, remove: bool) -> String {
     let first = text.chars().next().unwrap_or_default();
     if first.is_numeric() {
         let n = if uppercase { 'N' } else { 'n' };
         format!("{}{}", n, text)
     } else if !first.is_ascii_alphanumeric() {
         if text.len() > 1 {
-            format!("{}{}", unicode(first, uppercase), &text[1..])
+            if remove {
+                text[1..].to_owned()
+            } else {
+                format!("{}{}", unicode(first, uppercase), &text[1..])
+            }
         } else {
             unicode(first, uppercase)
         }
@@ -100,6 +124,7 @@ fn is_keyword(word: &str) -> bool {
         "abstract"
             | "alignof"
             | "as"
+            | "async"
             | "become"
             | "box"
             | "break"
@@ -165,9 +190,9 @@ mod tests {
 
     #[test]
     fn test_replace_first() -> Result<(), Error> {
-        assert_eq!(replace_first(".", false), "u2e");
-        assert_eq!(replace_first("/", false), "u2f");
-        assert_eq!(replace_first("", false), "u0");
+        assert_eq!(replace_first(".", false, false), "u2e");
+        assert_eq!(replace_first("/", false, false), "u2f");
+        assert_eq!(replace_first("", false, false), "u0");
         Ok(())
     }
 
@@ -249,4 +274,34 @@ mod tests {
         assert_eq!("1.0".to_camel_case_ident()?.to_string(), "N1_0");
         Ok(())
     }
+
+    #[test]
+    fn test_async() -> Result<(), Error> {
+        assert_eq!("Async".to_snake_case_ident()?.to_string(), "async_");
+        Ok(())
+    }
+
+    #[test]
+    fn test_attr_qualified_name() -> Result<(), Error> {
+        assert_eq!("attr:qualifiedName".to_snake_case_ident()?.to_string(), "attr_qualified_name");
+        Ok(())
+    }
+
+    #[test]
+    fn test_filter() -> Result<(), Error> {
+        assert_eq!("$filter".to_snake_case_ident()?.to_string(), "filter");
+        Ok(())
+    }
+
+    #[test]
+    fn test_odata_type() -> Result<(), Error> {
+        assert_eq!("@odata.type".to_camel_case_ident()?.to_string(), "OdataType");
+        Ok(())
+    }
+
+    #[test]
+    fn test_10minutely() -> Result<(), Error> {
+        assert_eq!("_10minutely".to_camel_case_ident()?.to_string(), "N10minutely");
+        Ok(())
+    }
 }

services/autorust/openapi/src/parameter.rs

@@ -57,7 +57,8 @@ pub enum ParameterType {
     Query,
     Header,
     Body,
-    Form,
+    /// https://swagger.io/docs/specification/2-0/describing-parameters/#form-parameters
+    FormData,
 }
 
 #[derive(Clone, Debug, Deserialize, Serialize, PartialEq)]

services/autorust/openapi/tests/azure_rest_api_specs.rs

@@ -6,6 +6,8 @@ mod common;
 use common::*;
 
 const PATHS: &[&str] = &[
+    // empty tags[] & consumes[]
+    // "../../../../azure-rest-api-specs/specification/machinelearningservices/data-plane/Microsoft.MachineLearningServices/preview/2019-09-30/execution.json",
     "../../../../azure-rest-api-specs/specification/vmware/resource-manager/Microsoft.AVS/stable/2020-03-20/vmware.json",
     "../../../../azure-rest-api-specs/specification/batch/data-plane/Microsoft.Batch/stable/2020-03-01.11.0/BatchService.json",
     "../../../../azure-rest-api-specs/specification/security/resource-manager/common/v1/types.json",