Fixup dependency on forked serde_xml

Author: dsteeley

.github/workflows/samples-rust.yaml

@@ -50,7 +50,7 @@ jobs:
         working-directory: ${{ matrix.sample }}
         run: |
           set -e
-          # Skip samples/client/petstore/rust/ as it's tests are failing.
+          # Skip samples/client/petstore/rust/ as its tests are failing.
           if [[ "${{ matrix.sample }}" == "samples/client/petstore/rust/" ]]; then
             echo "Skipping tests for samples/client/petstore/rust/"
             exit 0

modules/openapi-generator/src/main/resources/rust-server-deprecated/Cargo.mustache

@@ -101,7 +101,8 @@ validator = { version = "0.16", features = ["derive"] }
 {{#usesXml}}
 # TODO: this should be updated to point at the official crate once
 # https://github.com/RReverser/serde-xml-rs/pull/45 is accepted upstream
-serde-xml-rs = {git = "https://github.com/Metaswitch/serde-xml-rs" , branch = "master"}
+#serde-xml-rs = {git = "https://github.com/Metaswitch/serde-xml-rs" , branch = "master"}
+serde-xml-rs = "0.8"
 {{/usesXml}}
 {{#apiUsesMultipart}}
 mime_0_2 = { package = "mime", version = "0.2.6", optional = true }

modules/openapi-generator/src/main/resources/rust-server-deprecated/models.mustache

@@ -159,13 +159,19 @@ impl ::std::str::FromStr for {{{classname}}} {
 {{#arrayModelType}}
 {{#vendorExtensions}}{{#x-item-xml-name}}// Utility function for wrapping list elements when serializing xml
 #[allow(non_snake_case)]
-fn wrap_in_{{{x-item-xml-name}}}<S>(item: &Vec<{{{arrayModelType}}}>, serializer: S) -> std::result::Result<S::Ok, S::Error>
+fn wrap_in_{{{x-item-xml-name}}}<S>(items: &Vec<{{{arrayModelType}}}>, serializer: S) -> std::result::Result<S::Ok, S::Error>
 where
     S: serde::ser::Serializer,
 {
-    serde_xml_rs::wrap_primitives(item, serializer, "{{{x-item-xml-name}}}")
-}
+    use serde::ser::SerializeMap;
 
+    let mut map = serializer.serialize_map(None)?;
+    for ref item in items {
+        map.serialize_key("{{{x-item-xml-name}}}")?;
+        map.serialize_value(item)?;
+    }
+    map.end()
+}
 {{/x-item-xml-name}}
 {{/vendorExtensions}}
 {{! vec}}
@@ -633,10 +639,10 @@ impl {{{classname}}} {
     #[allow(dead_code)]
     pub(crate) fn as_xml(&self) -> String {
         {{#xmlNamespace}}
-        let mut namespaces = std::collections::BTreeMap::new();
         // An empty string is used to indicate a global namespace in xmltree.
-        namespaces.insert("".to_string(), Self::NAMESPACE.to_string());
-        serde_xml_rs::to_string_with_namespaces(&self, namespaces).expect("impossible to fail to serialize")
+        let config = serde_xml_rs::SerdeXml::new()
+            .namespace("", Self::NAMESPACE);
+        config.to_string(&self).expect("impossible to fail to serialize")
         {{/xmlNamespace}}
         {{^xmlNamespace}}
         serde_xml_rs::to_string(&self).expect("impossible to fail to serialize")

modules/openapi-generator/src/main/resources/rust-server-deprecated/server-response-body-instance.mustache

@@ -12,11 +12,10 @@
                                                     let body = serde_xml_rs::to_string(&body).expect("impossible to fail to serialize");
       {{/x-has-namespace}}
       {{#x-has-namespace}}
-                                                    let mut namespaces = std::collections::BTreeMap::new();
-
                                                     // An empty string is used to indicate a global namespace in xmltree.
-                                                    namespaces.insert("".to_string(), {{{dataType}}}::NAMESPACE.to_string());
-                                                    let body = serde_xml_rs::to_string_with_namespaces(&body, namespaces).expect("impossible to fail to serialize");
+                                                    let config = serde_xml_rs::SerdeXml::new()
+                                                        .namespace("", {{{dataType}}}::NAMESPACE);
+                                                    let body = config.to_string(&body).expect("impossible to fail to serialize");
       {{/x-has-namespace}}
     {{/x-produces-xml}}
     {{#x-produces-json}}

modules/openapi-generator/src/main/resources/rust-server/Cargo.mustache

@@ -96,8 +96,8 @@ validator = { version = "0.20", features = ["derive"] }
 {{#usesXml}}
 # TODO: this should be updated to point at the official crate once
 # https://github.com/RReverser/serde-xml-rs/pull/45 is accepted upstream
-serde-xml-rs = {git = "https://github.com/Metaswitch/serde-xml-rs" , branch = "master"}
-{{/usesXml}}
+#serde-xml-rs = {git = "https://github.com/Metaswitch/serde-xml-rs" , branch = "master"}
+serde-xml-rs = "0.8"{{/usesXml}}
 {{#apiUsesMultipartFormData}}
 multipart = { version = "0.18", default-features = false, optional = true }
 {{/apiUsesMultipartFormData}}

modules/openapi-generator/src/main/resources/rust-server/models.mustache

@@ -158,11 +158,18 @@ impl ::std::str::FromStr for {{{classname}}} {
 {{#arrayModelType}}
 {{#vendorExtensions}}{{#x-item-xml-name}}// Utility function for wrapping list elements when serializing xml
 #[allow(non_snake_case)]
-fn wrap_in_{{{x-item-xml-name}}}<S>(item: &Vec<{{{arrayModelType}}}>, serializer: S) -> std::result::Result<S::Ok, S::Error>
+fn wrap_in_{{{x-item-xml-name}}}<S>(items: &Vec<{{{arrayModelType}}}>, serializer: S) -> std::result::Result<S::Ok, S::Error>
 where
     S: serde::ser::Serializer,
 {
-    serde_xml_rs::wrap_primitives(item, serializer, "{{{x-item-xml-name}}}")
+    use serde::ser::SerializeMap;
+
+    let mut map = serializer.serialize_map(None)?;
+    for ref item in items {
+        map.serialize_key("{{{x-item-xml-name}}}")?;
+        map.serialize_value(item)?;
+    }
+    map.end()
 }
 
 {{/x-item-xml-name}}
@@ -632,10 +639,10 @@ impl {{{classname}}} {
     #[allow(dead_code)]
     pub(crate) fn as_xml(&self) -> String {
         {{#xmlNamespace}}
-        let mut namespaces = std::collections::BTreeMap::new();
         // An empty string is used to indicate a global namespace in xmltree.
-        namespaces.insert("".to_string(), Self::NAMESPACE.to_string());
-        serde_xml_rs::to_string_with_namespaces(&self, namespaces).expect("impossible to fail to serialize")
+        let config = serde_xml_rs::SerdeXml::new()
+            .namespace("", Self::NAMESPACE);
+        config.to_string(&self).expect("impossible to fail to serialize")
         {{/xmlNamespace}}
         {{^xmlNamespace}}
         serde_xml_rs::to_string(&self).expect("impossible to fail to serialize")

modules/openapi-generator/src/main/resources/rust-server/server-response-body-instance.mustache

@@ -12,11 +12,10 @@
                                                     let body = serde_xml_rs::to_string(&body).expect("impossible to fail to serialize");
       {{/x-has-namespace}}
       {{#x-has-namespace}}
-                                                    let mut namespaces = std::collections::BTreeMap::new();
-
                                                     // An empty string is used to indicate a global namespace in xmltree.
-                                                    namespaces.insert("".to_string(), {{{dataType}}}::NAMESPACE.to_string());
-                                                    let body = serde_xml_rs::to_string_with_namespaces(&body, namespaces).expect("impossible to fail to serialize");
+                                                    let config = serde_xml_rs::SerdeXml::new()
+                                                        .namespace("", {{{dataType}}}::NAMESPACE);
+                                                    let body = config.to_string(&body).expect("impossible to fail to serialize");
       {{/x-has-namespace}}
     {{/x-produces-xml}}
     {{#x-produces-json}}

samples/client/petstore/c/unit-tests/manual-PetAPI.c

@@ -2,8 +2,10 @@
     #include <stdlib.h>
     #include <string.h>
     #include <assert.h>
+    #include <curl/curl.h>
     #include "../api/PetAPI.h"
 
+    void preInvokeFunc(CURL *curl);
 
     #define EXAMPLE_CATEGORY_NAME "Example Category"
     #define EXAMPLE_CATEGORY_ID 5
@@ -16,10 +18,15 @@
     #define EXAMPLE_TAG_2_ID 542353
     #define EXAMPLE_PET_ID 1234 // Set to 0 to generate a new pet
 
+void preInvokeFunc(CURL *curl) {
+    curl_easy_setopt(curl, CURLOPT_VERBOSE, 1L);
+    printf("CURL pre-invoke function called - verbose mode enabled\n");
+}
 
 int main() {
 // Add pet test
 	apiClient_t *apiClient = apiClient_create();
+	apiClient->curl_pre_invoke_func = preInvokeFunc;
 
 	char *categoryName = malloc(strlen(EXAMPLE_CATEGORY_NAME) + 1);
 	strcpy(categoryName, EXAMPLE_CATEGORY_NAME);

samples/openapi3/client/petstore/go/go-petstore-aws-signature/.gitignore

@@ -0,0 +1,24 @@
+# Compiled Object files, Static and Dynamic libs (Shared Objects)
+*.o
+*.a
+*.so
+
+# Folders
+_obj
+_test
+
+# Architecture specific extensions/prefixes
+*.[568vq]
+[568vq].out
+
+*.cgo1.go
+*.cgo2.c
+_cgo_defun.c
+_cgo_gotypes.go
+_cgo_export.*
+
+_testmain.go
+
+*.exe
+*.test
+*.prof

samples/openapi3/client/petstore/go/go-petstore-aws-signature/.openapi-generator-ignore

@@ -0,0 +1,23 @@
+# OpenAPI Generator Ignore
+# Generated by openapi-generator https://github.com/openapitools/openapi-generator
+
+# Use this file to prevent files from being overwritten by the generator.
+# The patterns follow closely to .gitignore or .dockerignore.
+
+# As an example, the C# client generator defines ApiClient.cs.
+# You can make changes and tell OpenAPI Generator to ignore just this file by uncommenting the following line:
+#ApiClient.cs
+
+# You can match any string of characters against a directory, file or extension with a single asterisk (*):
+#foo/*/qux
+# The above matches foo/bar/qux and foo/baz/qux, but not foo/bar/baz/qux
+
+# You can recursively match patterns against a directory, file or extension with a double asterisk (**):
+#foo/**/qux
+# This matches foo/bar/qux, foo/baz/qux, and foo/bar/baz/qux
+
+# You can also negate patterns with an exclamation (!).
+# For example, you can ignore all files in a docs folder with the file extension .md:
+#docs/*.md
+# Then explicitly reverse the ignore rule for a single file:
+#!docs/README.md