fix: resolve 29 cross-language parity issues across all 12 generators

Address all findings from cross-language audit: Ruby gsub fix, missing
tests, DateTime format standardization, proxy validation, transport
exception wrapping, multipart support, cookie escaping, binary response
handling, and consistent oneOf/anyOf serialization. Add JUnit @tag
annotations to all spec interfaces for per-language test filtering.
Update README with full 12-language documentation.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: mridang

README.md

@@ -21,12 +21,22 @@ Before code generation, the tool can preprocess and standardize your OpenAPI v3
 
 **Opinionated Code Generators**
 
-A set of custom generators that produce lean, modern clients for various languages. They are "opinionated" in that they make specific technology choices and generate only what is necessary.
-* **Java**: Generates a minimal client using Apache HttpClient for requests, Jackson for JSON serialization, and the modern `java.time` library for dates
-* **PHP**: Creates a Guzzle-based client that uses `camelCase` for variable and parameter naming and generates a `ModelInterface.php` for type-hinting.
-* **Python**: Produces a simple client built on `urllib3`. It generates the necessary `__init__.py` files to ensure the output is a well-formed Python package.
-* **Ruby**: Creates a modern client using Typhoeus for performance. It correctly generates namespaced modules and Zeitwerk-compatible, snake_cased filenames for seamless autoloading.
-* **Node.js / TypeScript**: A Fetch API-based client configured for modern JavaScript environments, supporting ES Modules with `.js` import extensions.
+A set of custom generators that produce lean, modern clients for 12 languages. They are "opinionated" in that they make specific technology choices and generate only what is necessary. All generators share a consistent architecture: a `BaseApi` for request construction, a `DefaultApiClient` for HTTP transport, an `ObjectSerializer` for JSON handling, a `ValueSerializer` for OpenAPI style/explode serialization, and `TransportOptions` for client configuration.
+
+| Generator | Language | HTTP Client | Serialization |
+|-----------|----------|-------------|---------------|
+| `java-plus` | Java | `java.net.http.HttpClient` | Jackson |
+| `kotlin-plus` | Kotlin | OkHttp | kotlinx.serialization |
+| `csharp-plus` | C# | `System.Net.Http.HttpClient` | `System.Text.Json` |
+| `node-plus` | Node.js / TypeScript | Fetch API (undici) | Native JSON |
+| `python-plus` | Python | urllib3 | Native JSON |
+| `ruby-plus` | Ruby | Faraday | Native JSON |
+| `php-plus` | PHP | Symfony HttpClient | Native JSON |
+| `go-plus` | Go | `net/http` | `encoding/json` |
+| `rust-plus` | Rust | reqwest | serde |
+| `swift-plus` | Swift | URLSession | `JSONEncoder`/`JSONDecoder` |
+| `dart-plus` | Dart | `package:http` | `dart:convert` |
+| `elixir-plus` | Elixir | Req | Jason |
 
 ## Installation
 
@@ -233,6 +243,123 @@ docker run --rm \
     --config="/local/config.yml"
 ```
 
+### Generate a C# Client
+
+```yaml
+packageName: PetstoreClient
+sourceFolder: src
+```
+
+```shell
+docker run --rm \
+  --volume="${PWD}:/local" \
+  my-generator generate \
+    --input-spec="/local/spec.json" \
+    --generator-name="csharp-plus" \
+    --output="/local/client" \
+    --config="/local/config.yml"
+```
+
+### Generate a Go Client
+
+```yaml
+packageName: petstore
+```
+
+```shell
+docker run --rm \
+  --volume="${PWD}:/local" \
+  my-generator generate \
+    --input-spec="/local/spec.json" \
+    --generator-name="go-plus" \
+    --output="/local/client" \
+    --config="/local/config.yml"
+```
+
+### Generate a Kotlin Client
+
+```yaml
+groupId: com.example
+invokerPackage: com.example.petstore
+apiPackage: com.example.petstore.api
+modelPackage: com.example.petstore.models
+```
+
+```shell
+docker run --rm \
+  --volume="${PWD}:/local" \
+  my-generator generate \
+    --input-spec="/local/spec.json" \
+    --generator-name="kotlin-plus" \
+    --output="/local/client" \
+    --config="/local/config.yml"
+```
+
+### Generate a Rust Client
+
+```yaml
+packageName: petstore
+```
+
+```shell
+docker run --rm \
+  --volume="${PWD}:/local" \
+  my-generator generate \
+    --input-spec="/local/spec.json" \
+    --generator-name="rust-plus" \
+    --output="/local/client" \
+    --config="/local/config.yml"
+```
+
+### Generate a Swift Client
+
+```yaml
+projectName: PetstoreClient
+```
+
+```shell
+docker run --rm \
+  --volume="${PWD}:/local" \
+  my-generator generate \
+    --input-spec="/local/spec.json" \
+    --generator-name="swift-plus" \
+    --output="/local/client" \
+    --config="/local/config.yml"
+```
+
+### Generate a Dart Client
+
+```yaml
+pubName: petstore_client
+pubVersion: 1.0.0
+```
+
+```shell
+docker run --rm \
+  --volume="${PWD}:/local" \
+  my-generator generate \
+    --input-spec="/local/spec.json" \
+    --generator-name="dart-plus" \
+    --output="/local/client" \
+    --config="/local/config.yml"
+```
+
+### Generate an Elixir Client
+
+```yaml
+packageName: petstore_client
+```
+
+```shell
+docker run --rm \
+  --volume="${PWD}:/local" \
+  my-generator generate \
+    --input-spec="/local/spec.json" \
+    --generator-name="elixir-plus" \
+    --output="/local/client" \
+    --config="/local/config.yml"
+```
+
 ## Caveats
 
 The following OAS 3.0 features are deliberately out of scope for this project:

src/main/resources/templates/csharp/base_api.mustache

@@ -136,7 +136,8 @@ public abstract class BaseApi
             Dictionary<string, string> cookies = effectiveAuth.GetCookieParams();
             if (cookies.Count > 0)
             {
-                string cookieStr = string.Join("; ", cookies.Select(c => c.Key + "=" + c.Value));
+                string cookieStr = string.Join("; ", cookies.Select(c =>
+                    Uri.EscapeDataString(c.Key) + "=" + Uri.EscapeDataString(c.Value)));
                 headers["Cookie"] =
                     headers.TryGetValue("Cookie", out string? existing)
                     && !string.IsNullOrEmpty(existing)

src/main/resources/templates/csharp/default_api_client.mustache

@@ -193,10 +193,27 @@ public sealed class DefaultApiClient : IApiClient, IDisposable
             }
         }
 
-        using HttpResponseMessage response = await _httpClient
-            .SendAsync(request)
-            .ConfigureAwait(false);
-        string responseBody = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
+        HttpResponseMessage response;
+        try
+        {
+            response = await _httpClient
+                .SendAsync(request)
+                .ConfigureAwait(false);
+        }
+        catch (HttpRequestException ex)
+        {
+            throw new ApiException(ex.Message, ex);
+        }
+        catch (TaskCanceledException ex) when (ex.InnerException is TimeoutException)
+        {
+            throw new ApiException("Request timed out", ex);
+        }
+
+        byte[] responseBytes = await response.Content.ReadAsByteArrayAsync().ConfigureAwait(false);
+        string responseBody = IsTextContentType(response.Content.Headers.ContentType?.MediaType)
+            ? Encoding.UTF8.GetString(responseBytes)
+            : Convert.ToBase64String(responseBytes);
+
         Dictionary<string, string> responseHeaders = [];
 
         foreach (KeyValuePair<string, IEnumerable<string>> header in response.Headers)
@@ -283,6 +300,23 @@ public sealed class DefaultApiClient : IApiClient, IDisposable
         return "gzip, deflate, br";
     }
 
+    /// <summary>
+    /// Determines whether the given media type represents text content
+    /// that is safe to decode as a UTF-8 string.
+    /// </summary>
+    /// <param name="mediaType">The Content-Type media type, or null.</param>
+    /// <returns><c>true</c> for text-like content types, <c>false</c> otherwise.</returns>
+    private static bool IsTextContentType(string? mediaType)
+    {
+        return string.IsNullOrEmpty(mediaType)
+            || mediaType.StartsWith("text/", StringComparison.OrdinalIgnoreCase)
+            || mediaType.Equals("application/json", StringComparison.OrdinalIgnoreCase)
+            || mediaType.Equals("application/xml", StringComparison.OrdinalIgnoreCase)
+            || mediaType.Equals("application/javascript", StringComparison.OrdinalIgnoreCase)
+            || mediaType.EndsWith("+json", StringComparison.OrdinalIgnoreCase)
+            || mediaType.EndsWith("+xml", StringComparison.OrdinalIgnoreCase);
+    }
+
     /// <inheritdoc/>
     public void Dispose()
     {

src/main/resources/templates/csharp/object_serializer.mustache

@@ -150,20 +150,20 @@ public class ObjectSerializer
 
     /// <summary>
     /// Resolve a oneOf schema by attempting deserialization against each candidate.
-    /// Each candidate is a function that accepts a JSON string and returns a
-    /// deserialized value, or throws on failure.
+    /// Each candidate is a function that accepts a parsed <see cref="JsonElement"/>
+    /// and returns a deserialized value, or throws on failure.
     /// Returns the first successful deserialization result.
     /// </summary>
-    public static object? ResolveOneOf(string json, params Func<string, object?>[] candidates)
+    public static object? ResolveOneOf(JsonElement json, params Func<JsonElement, object?>[] candidates)
     {
         ArgumentNullException.ThrowIfNull(candidates);
 
-        if (string.IsNullOrEmpty(json))
+        if (json.ValueKind is JsonValueKind.Undefined or JsonValueKind.Null)
         {
             return null;
         }
 
-        foreach (Func<string, object?> candidate in candidates)
+        foreach (Func<JsonElement, object?> candidate in candidates)
         {
             try
             {
@@ -186,11 +186,11 @@ public class ObjectSerializer
 
     /// <summary>
     /// Resolve an anyOf schema by attempting deserialization against each candidate.
-    /// Each candidate is a function that accepts a JSON string and returns a
-    /// deserialized value, or throws on failure.
+    /// Each candidate is a function that accepts a parsed <see cref="JsonElement"/>
+    /// and returns a deserialized value, or throws on failure.
     /// Returns the first successful deserialization result.
     /// </summary>
-    public static object? ResolveAnyOf(string json, params Func<string, object?>[] candidates)
+    public static object? ResolveAnyOf(JsonElement json, params Func<JsonElement, object?>[] candidates)
     {
         return ResolveOneOf(json, candidates);
     }

src/main/resources/templates/csharp/test/BaseApiTest.mustache

@@ -42,6 +42,21 @@ public class BaseApiTest
                 method, path, queryParams, headerParams, body,
                 accepts, contentType, typeof(T), auth);
         }
+
+        public async Task<object?> CallAsyncWithNullReturnType(
+            string method,
+            string path,
+            Dictionary<string, object?> queryParams,
+            Dictionary<string, string> headerParams,
+            object? body,
+            string[] accepts,
+            string contentType,
+            IAuthenticator? auth = null)
+        {
+            return await InvokeApiAsync<object>(
+                method, path, queryParams, headerParams, body,
+                accepts, contentType, null, auth);
+        }
     }
 
     private sealed class CapturingApiClient : IApiClient
@@ -174,6 +189,17 @@ public class BaseApiTest
         Assert.Equal("success", result!["message"]?.GetValue<string>());
     }
 
+    [Fact]
+    public async Task ReturnsNullWhenReturnTypeIsNull()
+    {
+        var result = await Api().CallAsyncWithNullReturnType(
+            "GET", "/api/test",
+            new Dictionary<string, object?>(),
+            new Dictionary<string, string>(),
+            null, ["application/json"], "application/json");
+        Assert.Null(result);
+    }
+
     [Fact]
     public async Task ReturnsRawStringForNonJson()
     {

src/main/resources/templates/csharp/test/DefaultApiClientTest.mustache

@@ -135,7 +135,7 @@ public class DefaultApiClientTest
 
         var client = new DefaultApiClient(transport);
 
-        await Assert.ThrowsAsync<TaskCanceledException>(() =>
+        await Assert.ThrowsAsync<ApiException>(() =>
             client.SendRequestAsync(
                 "GET",
                 new Uri(_fixture.WireMockHttpUrl + "/api/slow"),

src/main/resources/templates/csharp/transport_options.mustache

@@ -182,7 +182,17 @@ public sealed class TransportOptionsBuilder
     {
         if (proxy != null)
         {
-            _ = new Uri(proxy);
+            Uri uri = new(proxy);
+            if (uri.Scheme is not "http" and not "https")
+            {
+                throw new UriFormatException(
+                    $"Invalid proxy URL (must use http or https scheme): {proxy}");
+            }
+            if (string.IsNullOrEmpty(uri.Host))
+            {
+                throw new UriFormatException(
+                    $"Invalid proxy URL (missing host): {proxy}");
+            }
         }
         _proxy = proxy;
         return this;

src/main/resources/templates/dart/api_client.mustache

@@ -12,13 +12,14 @@ abstract class ApiClient {
   ///   - [method]: HTTP method (GET, POST, PUT, DELETE, etc.)
   ///   - [url]: fully qualified URL
   ///   - [headers]: caller-provided headers
-  ///   - [body]: request body, or null
+  ///   - [body]: request body as [Uint8List], [Map<String, Object>] for
+  ///     multipart form data, or null
   ///
   /// Returns an [ApiResponse] and throws on transport errors.
   Future<ApiResponse> sendRequest(
     String method,
     String url,
     Map<String, String> headers,
-    Uint8List? body,
+    Object? body,
   );
 }

src/main/resources/templates/dart/base_api.mustache

@@ -92,7 +92,7 @@ class BaseApi {
       final cookies = effectiveAuth.cookieParams();
       if (cookies.isNotEmpty) {
         final cookieParts = cookies.entries
-            .map((e) => '${e.key}=${e.value}')
+            .map((e) => '${Uri.encodeComponent(e.key)}=${Uri.encodeComponent(e.value)}')
             .toList();
         final cookieStr = cookieParts.join('; ');
         if (headers.containsKey('Cookie')) {