Implement Code Generation (#1)

Author: nkzou

.generator/schemas/v1/openapi.yaml

@@ -7,7 +7,7 @@
 from . import formatter
 from . import utils
 
-MODULE = "github.com/DataDog/datadog-api-client-go/v2"
+MODULE = "datadog-api-client-rust"
 COMMON_PACKAGE_NAME = "datadog"
 
 
@@ -24,7 +24,7 @@
 )
 def cli(specs, output):
     """
-    Generate a Go code snippet from OpenAPI specification.
+    Generate a Rust code snippet from OpenAPI specification.
     """
     env = Environment(loader=FileSystemLoader(str(pathlib.Path(__file__).parent / "templates")))
 
@@ -41,7 +41,6 @@ def cli(specs, output):
     env.filters["parameters"] = openapi.parameters
     env.filters["form_parameter"] = openapi.form_parameter
     env.filters["response_type"] = openapi.get_type_for_response
-    env.filters["responses_by_types"] = openapi.responses_by_types
     env.filters["return_type"] = openapi.return_type
     env.filters["simple_type"] = formatter.simple_type
     env.filters["snake_case"] = formatter.snake_case
@@ -50,10 +49,12 @@ def cli(specs, output):
     env.filters["variable_name"] = formatter.variable_name
 
     env.globals["enumerate"] = enumerate
+    env.globals["responses_by_types"] = openapi.responses_by_types
     env.globals["get_name"] = openapi.get_name
     env.globals["get_type_for_attribute"] = openapi.get_type_for_attribute
+    env.globals["get_type_for_response"] = openapi.get_type_for_response
     env.globals["get_type_for_parameter"] = openapi.get_type_for_parameter
-    env.globals["get_type"] = openapi.type_to_go
+    env.globals["get_type"] = openapi.type_to_rust
     env.globals["get_default"] = openapi.get_default
     env.globals["get_container"] = openapi.get_container
     env.globals["get_container_type"] = openapi.get_container_type
@@ -63,17 +64,18 @@ def cli(specs, output):
 
     api_j2 = env.get_template("api.j2")
     model_j2 = env.get_template("model.j2")
-    doc_j2 = env.get_template("doc.j2")
+    mod_j2 = env.get_template("mod.j2")
+    mod_api_j2 = env.get_template("mod_api.j2")
+    mod_model_j2 = env.get_template("mod_model.j2")
+    # doc_j2 = env.get_template("doc.j2")
 
-    extra_files = {
+    common_files = {
         "configuration.rs": env.get_template("configuration.j2"),
-        "mod.rs": env.get_template("mod.j2"),
-        "lib.rs": env.get_template("lib.j2"),
+        "mod.rs": env.get_template("common_mod.j2"),
     }
+    librs = env.get_template("lib.j2")
 
-    # test_scenarios_files = {
-    #     "api_mappings.rs": env.get_template("scenarios_api_mappings.j2"),
-    # }
+    test_fixtures = env.get_template("function_mappings.j2")
 
     output.mkdir(parents=True, exist_ok=True)
 
@@ -97,34 +99,50 @@ def cli(specs, output):
 
         for name, model in models.items():
             filename = "model_" + formatter.model_filename(name) + ".rs"
-            model_path = resources_dir / filename
+            model_path = resources_dir / "model" / filename
             model_path.parent.mkdir(parents=True, exist_ok=True)
             with model_path.open("w") as fp:
                 fp.write(model_j2.render(name=name, model=model, models=models))
 
+        mod_path = resources_dir / "model" / "mod.rs"
+        with mod_path.open("w") as fp:
+            fp.write(mod_model_j2.render(apis=apis, models=models))
+
         all_operations = []
 
         for name, operations in apis.items():
             filename = "api_" + formatter.snake_case(name) + ".rs"
-            api_path = resources_dir / filename
+            api_path = resources_dir / "api" / filename
             api_path.parent.mkdir(parents=True, exist_ok=True)
             with api_path.open("w") as fp:
                 fp.write(api_j2.render(name=name, operations=operations))
             all_operations.append((name, operations))
 
+        mod_path = resources_dir / "api" / "mod.rs"
+        with mod_path.open("w") as fp:
+            fp.write(mod_api_j2.render(apis=apis, models=models))
+
+        mod_path = resources_dir / "mod.rs"
+        with mod_path.open("w") as fp:
+            fp.write(mod_j2.render(apis=apis, models=models))
+
+
         # doc_path = resources_dir / "doc.rs"
         # with doc_path.open("w") as fp:
         #     fp.write(doc_j2.render(all_operations=all_operations))
 
-    common_package_output = pathlib.Path(f"../api/{COMMON_PACKAGE_NAME}")
+    common_package_output = pathlib.Path(f"../src/{COMMON_PACKAGE_NAME}")
     common_package_output.mkdir(parents=True, exist_ok=True)
-    for name, template in extra_files.items():
+    for name, template in common_files.items():
         filename = common_package_output / name
         with filename.open("w") as fp:
             fp.write(template.render(apis=all_apis, all_specs=all_specs))
-    
-    # scenarios_test_output = pathlib.Path("../tests/scenarios/")
-    # for name, template in test_scenarios_files.items():
-    #     filename = scenarios_test_output / name
-    #     with filename.open("w") as fp:
-    #         fp.write(template.render(apis=all_apis, all_specs=all_specs))
+
+    lib_name = output / "lib.rs"
+    with lib_name.open("w") as fp:
+        fp.write(librs.render())
+
+    test_fixture_output = pathlib.Path("../tests/scenarios/")
+    filename = test_fixture_output / "function_mappings.rs"
+    with filename.open("w") as fp:
+        fp.write(test_fixtures.render(all_apis=all_apis, all_specs=all_specs))

.generator/schemas/v2/openapi.yaml

@@ -9,63 +9,57 @@
 PRIMITIVE_TYPES = ["string", "number", "boolean", "integer"]
 
 KEYWORDS = {
+    "as",
     "break",
-    "case",
-    "chan",
     "const",
     "continue",
-    "default",
-    "defer",
+    "crate",
     "else",
-    "fallthrough",
+    "enum",
+    "extern",
+    "false",
+    "fn",
     "for",
-    "func",
-    "go",
-    "goto",
     "if",
-    "import",
-    "interface",
-    "map",
-    "package",
-    "range",
+    "impl",
+    "in",
+    "let",
+    "loop",
+    "match",
+    "mod",
+    "move",
+    "mut",
+    "pub",
+    "ref",
     "return",
-    "select",
+    "self",
+    "Self",
+    "static",
     "struct",
-    "switch",
+    "super",
+    "trait",
+    "true",
     "type",
-    "var",
-}
-
-SUFFIXES = {
-    # Test
-    "test",
-    # $GOOS
-    "aix",
-    "android",
-    "darwin",
-    "dragonfly",
-    "freebsd",
-    "illumos",
-    "js",
-    "linux",
-    "netbsd",
-    "openbsd",
-    "plan9",
-    "solaris",
-    "windows",
-    # $GOARCH
-    "386",
-    "amd64",
-    "arm",
-    "arm64",
-    "mips",
-    "mips64",
-    "mips64le",
-    "mipsle",
-    "ppc64",
-    "ppc64le",
-    "s390x",
-    "wasm",
+    "unsafe",
+    "use",
+    "where",
+    "while",
+    "async",
+    "await",
+    "dyn",
+    "abstract",
+    "become",
+    "box",
+    "do",
+    "final",
+    "macro",
+    "override",
+    "priv",
+    "typeof",
+    "unsized",
+    "virtual",
+    "yield",
+    "try",
 }
 
 
@@ -74,18 +68,14 @@ def is_primitive(schema):
     return _type in PRIMITIVE_TYPES and "enum" not in schema
 
 
-def block_comment(comment, prefix="#", first_line=True):
+def block_comment(comment, prefix="///", first_line=True):
     lines = comment.split("\n")
     start = "" if first_line else lines[0] + "\n"
     return (start + "\n".join(f"{prefix} {line}".rstrip() for line in lines[(0 if first_line else 1) :])).rstrip()
 
 
 def model_filename(name):
-    filename = snake_case(name)
-    last = filename.split("_")[-1]
-    if last in SUFFIXES:
-        filename += "_"
-    return filename
+    return snake_case(name)
 
 
 def escape_reserved_keyword(word):
@@ -95,7 +85,7 @@ def escape_reserved_keyword(word):
     :return: The escaped word if it was a reserved keyword, the word unchanged otherwise
     """
     if word in KEYWORDS:
-        return f"{word}Var"
+        return f"{word}_"
     return word
 
 
@@ -104,15 +94,15 @@ def attribute_name(attribute):
 
 
 def variable_name(attribute):
-    return escape_reserved_keyword(untitle_case(camel_case(attribute)))
+    return escape_reserved_keyword(snake_case(attribute))
 
 
-def format_value(value, quotes='"', schema=None):
+def format_value(value, quotes='"', schema=None, version=None):
     if schema and "enum" in schema:
         index = schema["enum"].index(value)
         enum_varnames = schema["x-enum-varnames"][index]
         name = schema_name(schema)
-        return f"{name.upper()}_{enum_varnames}"
+        return f"crate::datadog{version.upper()}::model::{name}::{enum_varnames}"
 
     if isinstance(value, str):
         return f"{quotes}{value}{quotes}"
@@ -123,7 +113,7 @@ def format_value(value, quotes='"', schema=None):
     return value
 
 
-def simple_type(schema, render_nullable=False, render_new=False):
+def simple_type(schema, render_nullable=False, render_option=True, render_new=False):
     """Return the simple type of a schema.
 
     :param schema: The schema to extract the type from
@@ -132,34 +122,41 @@ def simple_type(schema, render_nullable=False, render_new=False):
     type_name = schema.get("type")
     type_format = schema.get("format")
     nullable = render_nullable and schema.get("nullable", False)
-
-    nullable_prefix = "datadog.NewNullable" if render_new else "datadog.Nullable"
-
+    
+    inner_type = None
     if type_name == "integer":
-        return {
-            "int32": "int32" if not nullable else f"{nullable_prefix}Int32",
-            "int64": "int64" if not nullable else f"{nullable_prefix}Int64",
-            None: "int32" if not nullable else f"{nullable_prefix}Int32",
+        inner_type = {
+            "int32": "i32",
+            "int64": "i64",
+            None: "i32",
         }[type_format]
 
     if type_name == "number":
-        return {
-            "double": "float64" if not nullable else f"{nullable_prefix}Float64",
-            None: "float" if not nullable else f"{nullable_prefix}Float",
+        inner_type = {
+            "double": "f64",
+            None: "f64",
         }[type_format]
 
     if type_name == "string":
-        return {
-            "date": "time.Time" if not nullable else f"{nullable_prefix}Time",
-            "date-time": "time.Time" if not nullable else f"{nullable_prefix}Time",
-            "email": "string" if not nullable else f"{nullable_prefix}String",
-            "binary": "*os.File",
-            None: "string" if not nullable else f"{nullable_prefix}String",
+        inner_type = {
+            "date": "String",
+            "date-time": "String",
+            "email": "String",
+            "binary": "Vec<u8>",
+            None: "String",
         }[type_format]
     if type_name == "boolean":
-        return "bool" if not nullable else f"{nullable_prefix}Bool"
+        inner_type = "bool"
+    
+    if inner_type == None:
+        return None
 
-    return None
+    simple_type = inner_type
+    if nullable:
+        simple_type = f"Option<{simple_type}>"
+    if render_option:
+        simple_type = f"Option<{simple_type}>"
+    return simple_type
 
 
 def is_reference(schema, attribute):
@@ -195,7 +192,7 @@ def attribute_path(attribute):
 
 
 def go_name(name):
-    """Convert key to Go name.
+    """Convert key to Rust name.
 
     Example:
 
@@ -398,7 +395,7 @@ def format_data_with_schema(
     if replace_values and data in replace_values:
         parameters = replace_values[data]
 
-        # Make sure that variables used in given statements are camelCase for Go linter
+        # Make sure that variables used in given statements are camelCase for Rust linter
         if parameters in variables:
             parameters = go_name(parameters)
 
@@ -651,7 +648,7 @@ def format_data_with_schema_dict(
             else:
                 parameters = saved_parameters
         else:
-            return f"map[string]{nested_schema_name}{{\n{parameters}}}"
+            return f"None"#f"map[string]{nested_schema_name}{{\n{parameters}}}"
 
     if "oneOf" in schema:
         return _format_oneof(schema, data, name, name_prefix, replace_values, required, nullable, **kwargs)