adding_ruby_net_http

lib/codegen/codegen.dart

@@ -20,6 +20,7 @@ import 'julia/http.dart';
 import 'java/okhttp.dart';
 import 'java/async_http_client.dart';
 import 'java/httpclient.dart';
+import 'ruby/net_http.dart';
 
 class Codegen {
   String? getCode(
@@ -82,6 +83,8 @@ class Codegen {
         return RustUreqCodeGen().getCode(rM, boundary: boundary);
       case CodegenLanguage.phpGuzzle:
         return PhpGuzzleCodeGen().getCode(rM);
+      case CodegenLanguage.rubyNetHttp:
+        return rubyCodeGen().getCode(rM);
     }
   }
 }

lib/codegen/ruby/net_http.dart

@@ -0,0 +1,119 @@
+import 'package:jinja/jinja.dart' as jj;
+import 'package:apidash/utils/utils.dart'
+    show padMultilineString, requestModelToHARJsonRequest;
+import 'package:apidash/models/models.dart' show RequestModel;
+import 'package:apidash/consts.dart';
+
+class rubyCodeGen {
+  String kTemplateStart = """  require "uri"
+  require "net/http"
+  {% if type == "application/json" %}require "json"{% endif %}
+  url = URI("{{url}}")
+  https = Net::HTTP.new(url.host, url.port)
+  {% if check == "https" %}https.use_ssl = true{% endif %}
+  request = Net::HTTP::{{method}}.new(url)
+""";
+
+  String kTemplateHeader = """
+
+  {% for header in headers %}
+  {% if 'multipart' not in header['value'] %}request["{{ header['name'] }}"] = "{{ header['value'] }}"{% endif %}{% endfor %}
+""";
+
+  String kTemplateBody = """
+
+  request.body = JSON.dump({{body}})
+""";
+
+  String kTemplateTextBody = """
+
+  request.body = {{body}};
+""";
+  String kMultiPartBodyTemplate = r'''
+{% if type == "file" %}"{{name}}", File.open("{{value}}"){% else %}"{{name}}", "{{value}}"{% endif %}
+''';
+  String kStringRequest = """
+
+  response = https.request(request)
+
+  puts "Response Code: #{response.code}"
+  {% if method != "HEAD" %}puts "Response Body: #{response.body}"{% else %}puts "Response Body: #{response.to_hash}"{% endif %}
+  
+""";
+
+  String? getCode(RequestModel requestModel) {
+    try {
+      String result = "";
+
+      var harJson =
+          requestModelToHARJsonRequest(requestModel, useEnabled: true);
+
+      var templateStart = jj.Template(kTemplateStart);
+      result += templateStart.render({
+        "url": harJson["url"],
+        "method": harJson["method"].toString().substring(0, 1).toUpperCase() +
+            harJson["method"].toString().substring(1).toLowerCase(),
+        "type": harJson["postData"]?["mimeType"],
+        "check": harJson["url"].toString().substring(0, 5),
+      });
+
+      var headers = harJson["headers"];
+      if (headers.isNotEmpty) {
+        var templateHeader = jj.Template(kTemplateHeader);
+        result += templateHeader.render({
+          "headers": headers,
+        });
+        // if (harJson["postData"]?["mimeType"].toString().substring(0, 9) !=
+        //     "multipart") {
+        //   var templateHeader = jj.Template(kTemplateHeader);
+        //   result += templateHeader.render({
+        //     "headers": headers,
+        //   });
+        // }
+      }
+
+      if (harJson["postData"]?["mimeType"] == "application/json") {
+        var templateBody = jj.Template(kTemplateBody);
+        result += templateBody.render({
+          "body": kEncoder.convert(harJson["postData"]["text"]),
+        });
+      } else if (harJson["postData"]?["mimeType"] == "text/plain") {
+        var templateBody = jj.Template(kTemplateTextBody);
+        result += templateBody.render({
+          "body": kEncoder.convert(harJson["postData"]["text"]),
+        });
+      }
+
+      if (requestModel.hasFormData) {
+        result += "\n";
+        result += "  form_data = [";
+        var templateMultiPartBody = jj.Template(kMultiPartBodyTemplate);
+        int length = requestModel.formDataMapList.length;
+  
+        for (var element in requestModel.formDataMapList) {
+          result += "[";
+          result += templateMultiPartBody.render({
+            "name": element["name"],
+            "value": element["value"],
+            "type": element["type"]
+          });
+          length -= 1;
+          if (length == 0) {
+            result += "]";
+          } else {
+            result += "],";
+          }
+        }
+        // result.substring(0,result.length - 1);
+        result += "]\n";
+        result += "  request.set_form form_data, 'multipart/form-data'";
+      }
+
+      result +=
+          jj.Template(kStringRequest).render({"method": harJson["method"]});
+      return result;
+    } catch (e) {
+      return null;
+    }
+  }
+}

lib/consts.dart

@@ -294,7 +294,8 @@ enum CodegenLanguage {
   javaAsyncHttpClient("Java (asynchttpclient)", "java", "java"),
   javaHttpClient("Java (HttpClient)", "java", "java"),
   juliaHttp("Julia (HTTP)", "julia", "jl"),
-  phpGuzzle("PHP (guzzle)", "php", "php");
+  phpGuzzle("PHP (guzzle)", "php", "php"),
+  rubyNetHttp("Ruby (Net::Http)", "Ruby", "rb");
 
   const CodegenLanguage(this.label, this.codeHighlightLang, this.ext);
   final String label;

test/codegen/ruby_net_http_codegen_test.dart

@@ -0,0 +1,600 @@
+import 'package:apidash/codegen/codegen.dart';
+import 'package:apidash/consts.dart';
+import 'package:test/test.dart';
+import '../request_models.dart';
+
+void main() {
+  final codeGen = Codegen();
+
+  group('GET Request', () {
+    test('GET 1', () {
+      const expectedCode = r"""  require "uri"
+  require "net/http"
+  
+  url = URI("https://api.apidash.dev")
+  https = Net::HTTP.new(url.host, url.port)
+  https.use_ssl = true
+  request = Net::HTTP::Get.new(url)
+  response = https.request(request)
+
+  puts "Response Code: #{response.code}"
+  puts "Response Body: #{response.body}"
+  """;
+      expect(
+          codeGen.getCode(CodegenLanguage.rubyNetHttp, requestModelGet1, "https"),
+          expectedCode);
+    });
+
+    test('GET 2', () {
+      const expectedCode =
+          r"""  require "uri"
+  require "net/http"
+  
+  url = URI("https://api.apidash.dev/country/data?code=US")
+  https = Net::HTTP.new(url.host, url.port)
+  https.use_ssl = true
+  request = Net::HTTP::Get.new(url)
+  response = https.request(request)
+
+  puts "Response Code: #{response.code}"
+  puts "Response Body: #{response.body}"
+  """;
+      expect(
+          codeGen.getCode(CodegenLanguage.rubyNetHttp, requestModelGet2, "https"),
+          expectedCode);
+    });
+
+    test('GET 3', () {
+      const expectedCode =
+          r"""  require "uri"
+  require "net/http"
+  
+  url = URI("https://api.apidash.dev/country/data?code=IND")
+  https = Net::HTTP.new(url.host, url.port)
+  https.use_ssl = true
+  request = Net::HTTP::Get.new(url)
+  response = https.request(request)
+
+  puts "Response Code: #{response.code}"
+  puts "Response Body: #{response.body}"
+  """;
+      expect(
+          codeGen.getCode(CodegenLanguage.rubyNetHttp, requestModelGet3, "https"),
+          expectedCode);
+    });
+
+    test('GET 4', () {
+      const expectedCode =
+          r"""  require "uri"
+  require "net/http"
+  
+  url = URI("https://api.apidash.dev/humanize/social?num=8700000&digits=3&system=SS&add_space=true&trailing_zeros=true")
+  https = Net::HTTP.new(url.host, url.port)
+  https.use_ssl = true
+  request = Net::HTTP::Get.new(url)
+  response = https.request(request)
+
+  puts "Response Code: #{response.code}"
+  puts "Response Body: #{response.body}"
+  """;
+      expect(
+          codeGen.getCode(CodegenLanguage.rubyNetHttp, requestModelGet4, "https"),
+          expectedCode);
+    });
+
+    test('GET 5', () {
+      const expectedCode =
+          r"""  require "uri"
+  require "net/http"
+  
+  url = URI("https://api.github.com/repos/foss42/apidash")
+  https = Net::HTTP.new(url.host, url.port)
+  https.use_ssl = true
+  request = Net::HTTP::Get.new(url)
+  
+  request["User-Agent"] = "Test Agent"
+  response = https.request(request)
+
+  puts "Response Code: #{response.code}"
+  puts "Response Body: #{response.body}"
+  """;
+      expect(
+          codeGen.getCode(CodegenLanguage.rubyNetHttp, requestModelGet5, "https"),
+          expectedCode);
+    });
+
+    test('GET 6', () {
+      const expectedCode =
+          r"""  require "uri"
+  require "net/http"
+  
+  url = URI("https://api.github.com/repos/foss42/apidash?raw=true")
+  https = Net::HTTP.new(url.host, url.port)
+  https.use_ssl = true
+  request = Net::HTTP::Get.new(url)
+  
+  request["User-Agent"] = "Test Agent"
+  response = https.request(request)
+
+  puts "Response Code: #{response.code}"
+  puts "Response Body: #{response.body}"
+  """;
+      expect(
+          codeGen.getCode(CodegenLanguage.rubyNetHttp, requestModelGet6, "https"),
+          expectedCode);
+    });
+
+    test('GET 7', () {
+      const expectedCode = r"""  require "uri"
+  require "net/http"
+  
+  url = URI("https://api.apidash.dev")
+  https = Net::HTTP.new(url.host, url.port)
+  https.use_ssl = true
+  request = Net::HTTP::Get.new(url)
+  response = https.request(request)
+
+  puts "Response Code: #{response.code}"
+  puts "Response Body: #{response.body}"
+  """;
+      expect(
+          codeGen.getCode(CodegenLanguage.rubyNetHttp, requestModelGet7, "https"),
+          expectedCode);
+    });
+
+    test('GET 8', () {
+      const expectedCode =
+          r"""  require "uri"
+  require "net/http"
+  
+  url = URI("https://api.github.com/repos/foss42/apidash?raw=true")
+  https = Net::HTTP.new(url.host, url.port)
+  https.use_ssl = true
+  request = Net::HTTP::Get.new(url)
+  
+  request["User-Agent"] = "Test Agent"
+  response = https.request(request)
+
+  puts "Response Code: #{response.code}"
+  puts "Response Body: #{response.body}"
+  """;
+      expect(
+          codeGen.getCode(CodegenLanguage.rubyNetHttp, requestModelGet8, "https"),
+          expectedCode);
+    });
+
+    test('GET 9', () {
+      const expectedCode =
+          r"""  require "uri"
+  require "net/http"
+  
+  url = URI("https://api.apidash.dev/humanize/social?num=8700000&add_space=true")
+  https = Net::HTTP.new(url.host, url.port)
+  https.use_ssl = true
+  request = Net::HTTP::Get.new(url)
+  response = https.request(request)
+
+  puts "Response Code: #{response.code}"
+  puts "Response Body: #{response.body}"
+  """;
+      expect(
+          codeGen.getCode(CodegenLanguage.rubyNetHttp, requestModelGet9, "https"),
+          expectedCode);
+    });
+
+    test('GET 10', () {
+      const expectedCode =
+          r"""  require "uri"
+  require "net/http"
+  
+  url = URI("https://api.apidash.dev/humanize/social")
+  https = Net::HTTP.new(url.host, url.port)
+  https.use_ssl = true
+  request = Net::HTTP::Get.new(url)
+  
+  request["User-Agent"] = "Test Agent"
+  response = https.request(request)
+
+  puts "Response Code: #{response.code}"
+  puts "Response Body: #{response.body}"
+  """;
+      expect(
+          codeGen.getCode(
+            CodegenLanguage.rubyNetHttp,
+            requestModelGet10,
+            "https",
+          ),
+          expectedCode);
+    });
+
+    test('GET 11', () {
+      const expectedCode =
+          r"""  require "uri"
+  require "net/http"
+  
+  url = URI("https://api.apidash.dev/humanize/social?num=8700000&digits=3")
+  https = Net::HTTP.new(url.host, url.port)
+  https.use_ssl = true
+  request = Net::HTTP::Get.new(url)
+  
+  request["User-Agent"] = "Test Agent"
+  response = https.request(request)
+
+  puts "Response Code: #{response.code}"
+  puts "Response Body: #{response.body}"
+  """;
+      expect(
+          codeGen.getCode(CodegenLanguage.rubyNetHttp, requestModelGet11, "https"),
+          expectedCode);
+    });
+
+    test('GET 12', () {
+      const expectedCode =
+          r"""  require "uri"
+  require "net/http"
+  
+  url = URI("https://api.apidash.dev/humanize/social")
+  https = Net::HTTP.new(url.host, url.port)
+  https.use_ssl = true
+  request = Net::HTTP::Get.new(url)
+  response = https.request(request)
+
+  puts "Response Code: #{response.code}"
+  puts "Response Body: #{response.body}"
+  """;
+      expect(
+          codeGen.getCode(CodegenLanguage.rubyNetHttp, requestModelGet12, "https"),
+          expectedCode);
+    });
+  });
+
+  group('HEAD Request', () {
+    test('HEAD 1', () {
+      const expectedCode = r"""  require "uri"
+  require "net/http"
+  
+  url = URI("https://api.apidash.dev")
+  https = Net::HTTP.new(url.host, url.port)
+  https.use_ssl = true
+  request = Net::HTTP::Head.new(url)
+  response = https.request(request)
+
+  puts "Response Code: #{response.code}"
+  puts "Response Body: #{response.to_hash}"
+  """;
+      expect(
+          codeGen.getCode(CodegenLanguage.rubyNetHttp, requestModelHead1, "https"),
+          expectedCode);
+    });
+
+    test('HEAD 2', () {
+      const expectedCode = r"""  require "uri"
+  require "net/http"
+  
+  url = URI("http://api.apidash.dev")
+  https = Net::HTTP.new(url.host, url.port)
+  
+  request = Net::HTTP::Head.new(url)
+  response = https.request(request)
+
+  puts "Response Code: #{response.code}"
+  puts "Response Body: #{response.to_hash}"
+  """;
+      expect(
+          codeGen.getCode(CodegenLanguage.rubyNetHttp, requestModelHead2, "http"),
+          expectedCode);
+    });
+  });
+
+  group('POST Request', () {
+    test('POST 1', () {
+      const expectedCode = r"""  require "uri"
+  require "net/http"
+  
+  url = URI("https://api.apidash.dev/case/lower")
+  https = Net::HTTP.new(url.host, url.port)
+  https.use_ssl = true
+  request = Net::HTTP::Post.new(url)
+  
+  request["Content-Type"] = "text/plain"
+  request.body = "{\n\"text\": \"I LOVE Flutter\"\n}";
+  response = https.request(request)
+
+  puts "Response Code: #{response.code}"
+  puts "Response Body: #{response.body}"
+  """;
+      expect(
+          codeGen.getCode(CodegenLanguage.rubyNetHttp, requestModelPost1, "https"),
+          expectedCode);
+    });
+
+    test('POST 2', () {
+      const expectedCode = r"""  require "uri"
+  require "net/http"
+  require "json"
+  url = URI("https://api.apidash.dev/case/lower")
+  https = Net::HTTP.new(url.host, url.port)
+  https.use_ssl = true
+  request = Net::HTTP::Post.new(url)
+  
+  request["Content-Type"] = "application/json"
+  request.body = JSON.dump("{\n\"text\": \"I LOVE Flutter\",\n\"flag\": null,\n\"male\": true,\n\"female\": false,\n\"no\": 1.2,\n\"arr\": [\"null\", \"true\", \"false\", null]\n}")
+  response = https.request(request)
+
+  puts "Response Code: #{response.code}"
+  puts "Response Body: #{response.body}"
+  """;
+      expect(
+          codeGen.getCode(CodegenLanguage.rubyNetHttp, requestModelPost2, "https"),
+          expectedCode);
+    });
+
+    test('POST 3', () {
+      const expectedCode = r"""  require "uri"
+  require "net/http"
+  require "json"
+  url = URI("https://api.apidash.dev/case/lower")
+  https = Net::HTTP.new(url.host, url.port)
+  https.use_ssl = true
+  request = Net::HTTP::Post.new(url)
+  
+  request["Content-Type"] = "application/json"
+  request["User-Agent"] = "Test Agent"
+  request.body = JSON.dump("{\n\"text\": \"I LOVE Flutter\"\n}")
+  response = https.request(request)
+
+  puts "Response Code: #{response.code}"
+  puts "Response Body: #{response.body}"
+  """;
+      expect(
+          codeGen.getCode(CodegenLanguage.rubyNetHttp, requestModelPost3, "https"),
+          expectedCode);
+    });
+    test('POST 4', () {
+      const expectedCode = r"""  require "uri"
+  require "net/http"
+  
+  url = URI("https://api.apidash.dev/io/form")
+  https = Net::HTTP.new(url.host, url.port)
+  https.use_ssl = true
+  request = Net::HTTP::Post.new(url)
+  
+  
+  form_data = [["text", "API"],["sep", "|"],["times", "3"]]
+  request.set_form form_data, 'multipart/form-data'
+  response = https.request(request)
+
+  puts "Response Code: #{response.code}"
+  puts "Response Body: #{response.body}"
+  """;
+      expect(
+          codeGen.getCode(
+            CodegenLanguage.rubyNetHttp,
+            requestModelPost4,
+            "https",
+          ),
+          expectedCode);
+    });
+
+    test('POST 5', () {
+      const expectedCode = r"""  require "uri"
+  require "net/http"
+  
+  url = URI("https://api.apidash.dev/io/form")
+  https = Net::HTTP.new(url.host, url.port)
+  https.use_ssl = true
+  request = Net::HTTP::Post.new(url)
+  
+  
+  request["User-Agent"] = "Test Agent"
+  form_data = [["text", "API"],["sep", "|"],["times", "3"]]
+  request.set_form form_data, 'multipart/form-data'
+  response = https.request(request)
+
+  puts "Response Code: #{response.code}"
+  puts "Response Body: #{response.body}"
+  """;
+      expect(
+          codeGen.getCode(
+            CodegenLanguage.rubyNetHttp,
+            requestModelPost5,
+            "https",
+          ),
+          expectedCode);
+    });
+    test('POST 6', () {
+      const expectedCode =
+          r"""  require "uri"
+  require "net/http"
+  
+  url = URI("https://api.apidash.dev/io/img")
+  https = Net::HTTP.new(url.host, url.port)
+  https.use_ssl = true
+  request = Net::HTTP::Post.new(url)
+  
+  
+  form_data = [["token", "xyz"],["imfile", File.open("/Documents/up/1.png")]]
+  request.set_form form_data, 'multipart/form-data'
+  response = https.request(request)
+
+  puts "Response Code: #{response.code}"
+  puts "Response Body: #{response.body}"
+  """;
+      expect(
+          codeGen.getCode(
+            CodegenLanguage.rubyNetHttp,
+            requestModelPost6,
+            "https",
+          ),
+          expectedCode);
+    });
+    test('POST 7', () {
+      const expectedCode =
+          r"""  require "uri"
+  require "net/http"
+  
+  url = URI("https://api.apidash.dev/io/img")
+  https = Net::HTTP.new(url.host, url.port)
+  https.use_ssl = true
+  request = Net::HTTP::Post.new(url)
+  
+  
+  form_data = [["token", "xyz"],["imfile", File.open("/Documents/up/1.png")]]
+  request.set_form form_data, 'multipart/form-data'
+  response = https.request(request)
+
+  puts "Response Code: #{response.code}"
+  puts "Response Body: #{response.body}"
+  """;
+      expect(
+          codeGen.getCode(
+            CodegenLanguage.rubyNetHttp,
+            requestModelPost7,
+            "https",
+          ),
+          expectedCode);
+    });
+    test('POST 8', () {
+      const expectedCode = r"""  require "uri"
+  require "net/http"
+  
+  url = URI("https://api.apidash.dev/io/form?size=2&len=3")
+  https = Net::HTTP.new(url.host, url.port)
+  https.use_ssl = true
+  request = Net::HTTP::Post.new(url)
+  
+  
+  form_data = [["text", "API"],["sep", "|"],["times", "3"]]
+  request.set_form form_data, 'multipart/form-data'
+  response = https.request(request)
+
+  puts "Response Code: #{response.code}"
+  puts "Response Body: #{response.body}"
+  """;
+      expect(
+          codeGen.getCode(
+            CodegenLanguage.rubyNetHttp,
+            requestModelPost8,
+            "https",
+          ),
+          expectedCode);
+    });
+    test('POST 9', () {
+      const expectedCode =
+          r"""  require "uri"
+  require "net/http"
+  
+  url = URI("https://api.apidash.dev/io/img?size=2&len=3")
+  https = Net::HTTP.new(url.host, url.port)
+  https.use_ssl = true
+  request = Net::HTTP::Post.new(url)
+  
+  
+  request["User-Agent"] = "Test Agent"
+  request["Keep-Alive"] = "true"
+  form_data = [["token", "xyz"],["imfile", File.open("/Documents/up/1.png")]]
+  request.set_form form_data, 'multipart/form-data'
+  response = https.request(request)
+
+  puts "Response Code: #{response.code}"
+  puts "Response Body: #{response.body}"
+  """;
+      expect(
+          codeGen.getCode(
+            CodegenLanguage.rubyNetHttp,
+            requestModelPost9,
+            "https",
+          ),
+          expectedCode);
+    });
+  });
+
+  group('PUT Request', () {
+    test('PUT 1', () {
+      const expectedCode = r"""  require "uri"
+  require "net/http"
+  require "json"
+  url = URI("https://reqres.in/api/users/2")
+  https = Net::HTTP.new(url.host, url.port)
+  https.use_ssl = true
+  request = Net::HTTP::Put.new(url)
+  
+  request["Content-Type"] = "application/json"
+  request.body = JSON.dump("{\n\"name\": \"morpheus\",\n\"job\": \"zion resident\"\n}")
+  response = https.request(request)
+
+  puts "Response Code: #{response.code}"
+  puts "Response Body: #{response.body}"
+  """;
+      expect(
+          codeGen.getCode(CodegenLanguage.rubyNetHttp, requestModelPut1, "https"),
+          expectedCode);
+    });
+  });
+
+  group('PATCH Request', () {
+    test('PATCH 1', () {
+      const expectedCode = r"""  require "uri"
+  require "net/http"
+  require "json"
+  url = URI("https://reqres.in/api/users/2")
+  https = Net::HTTP.new(url.host, url.port)
+  https.use_ssl = true
+  request = Net::HTTP::Patch.new(url)
+  
+  request["Content-Type"] = "application/json"
+  request.body = JSON.dump("{\n\"name\": \"marfeus\",\n\"job\": \"accountant\"\n}")
+  response = https.request(request)
+
+  puts "Response Code: #{response.code}"
+  puts "Response Body: #{response.body}"
+  """;
+      expect(
+          codeGen.getCode(CodegenLanguage.rubyNetHttp, requestModelPatch1, "https"),
+          expectedCode);
+    });
+  });
+
+  group('DELETE Request', () {
+    test('DELETE 1', () {
+      const expectedCode = r"""  require "uri"
+  require "net/http"
+  
+  url = URI("https://reqres.in/api/users/2")
+  https = Net::HTTP.new(url.host, url.port)
+  https.use_ssl = true
+  request = Net::HTTP::Delete.new(url)
+  response = https.request(request)
+
+  puts "Response Code: #{response.code}"
+  puts "Response Body: #{response.body}"
+  """;
+      expect(
+          codeGen.getCode(
+              CodegenLanguage.rubyNetHttp, requestModelDelete1, "https"),
+          expectedCode);
+    });
+
+    test('DELETE 2', () {
+      const expectedCode = r"""  require "uri"
+  require "net/http"
+  require "json"
+  url = URI("https://reqres.in/api/users/2")
+  https = Net::HTTP.new(url.host, url.port)
+  https.use_ssl = true
+  request = Net::HTTP::Delete.new(url)
+  
+  request["Content-Type"] = "application/json"
+  request.body = JSON.dump("{\n\"name\": \"marfeus\",\n\"job\": \"accountant\"\n}")
+  response = https.request(request)
+
+  puts "Response Code: #{response.code}"
+  puts "Response Body: #{response.body}"
+  """;
+      expect(
+          codeGen.getCode(
+              CodegenLanguage.rubyNetHttp, requestModelDelete2, "https"),
+          expectedCode);
+    });
+  });
+}