datadog_api_client 1.7.0 → 1.8.0

data/.generator/src/generator/__main__.py

@@ -0,0 +1,3 @@
+from .cli import cli
+
+cli()

data/.generator/src/generator/cli.py

@@ -0,0 +1,97 @@
+import json
+import pathlib
+
+import click
+from jinja2 import Environment, FileSystemLoader, Template
+
+from . import openapi
+from . import formatter
+
+
+@click.command()
+@click.option(
+    "-i",
+    "--input",
+    type=click.Path(
+        exists=True, file_okay=True, dir_okay=False, path_type=pathlib.Path
+    ),
+)
+@click.option(
+    "-o",
+    "--output",
+    type=click.Path(path_type=pathlib.Path),
+)
+def cli(input, output):
+    """
+    Generate a Ruby code snippet from OpenAPI specification.
+    """
+    spec = openapi.load(input)
+
+    version = input.parent.name
+    with (input.parent.parent.parent / "config" / f"{version}.json").open() as fp:
+        config = json.load(fp)
+
+    env = Environment(
+        loader=FileSystemLoader(str(pathlib.Path(__file__).parent / "templates"))
+    )
+
+    env.filters["accept_headers"] = openapi.accept_headers
+    env.filters["attribute_name"] = formatter.attribute_name
+    env.filters["block_comment"] = formatter.block_comment
+    env.filters["camel_case"] = formatter.camel_case
+    env.filters["collection_format"] = openapi.collection_format
+    env.filters["format_server"] = openapi.format_server
+    env.filters["format_value"] = formatter.format_value
+    env.filters["parameter_schema"] = openapi.parameter_schema
+    env.filters["parameters"] = openapi.parameters
+    env.filters["return_type"] = openapi.return_type
+    env.filters["snake_case"] = formatter.snake_case
+
+    env.globals["config"] = config
+    env.globals["enumerate"] = enumerate
+    env.globals["version"] = version
+    env.globals["openapi"] = spec
+    env.globals["get_name"] = openapi.get_name
+    env.globals["get_type_for_attribute"] = openapi.get_type_for_attribute
+    env.globals["get_type_for_parameter"] = openapi.get_type_for_parameter
+
+    api_j2 = env.get_template("api.j2")
+    model_j2 = env.get_template("model.j2")
+    package_j2 = env.get_template("package.j2")
+
+    extra_files = {
+        "api_client.rb": env.get_template("api_client.j2"),
+        "api_error.rb": env.get_template("api_error.j2"),
+        "configuration.rb": env.get_template("configuration.j2"),
+        "model_base.rb": env.get_template("model_base.j2"),
+    }
+
+    apis = openapi.apis(spec)
+    models = openapi.models(spec)
+
+    package = output / config["gemNameInExamples"] / f"{version}.rb"
+    package.parent.mkdir(parents=True, exist_ok=True)
+    with package.open("w") as fp:
+        fp.write(package_j2.render(apis=apis, models=models))
+
+    gem_path = output / config["gemName"]
+    gem_path.mkdir(parents=True, exist_ok=True)
+
+    for name, template in extra_files.items():
+        filename = gem_path / name
+        with filename.open("w") as fp:
+            fp.write(template.render(apis=apis, models=models))
+
+    for name, model in models.items():
+        filename = formatter.snake_case(name) + ".rb"
+        model_path = gem_path / "models" / 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))
+
+    for name, operations in apis.items():
+        filename = formatter.snake_case(name) + "_api.rb"
+        api_path = gem_path / "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))

data/.generator/src/generator/formatter.py

@@ -0,0 +1,293 @@
+"""Data formatter."""
+import re
+import warnings
+from functools import singledispatch
+
+
+KEYWORDS = {
+    "__FILE__",
+    "and",
+    "def",
+    "end",
+    "in",
+    "or",
+    "self",
+    "unless",
+    "__LINE__",
+    "begin",
+    "defined?",
+    "ensure",
+    "module",
+    "redo",
+    "super",
+    "until",
+    "BEGIN",
+    "break",
+    "do",
+    "false",
+    "next",
+    "rescue",
+    "then",
+    "when",
+    "END",
+    "case",
+    "else",
+    "for",
+    "nil",
+    "retry",
+    "true",
+    "while",
+    "alias",
+    "class",
+    "elsif",
+    "if",
+    "not",
+    "return",
+    "undef",
+    "yield",
+}
+
+PATTERN_DOUBLE_UNDERSCORE = re.compile(r"__+")
+PATTERN_LEADING_ALPHA = re.compile(r"(.)([A-Z][a-z]+)")
+PATTERN_FOLLOWING_ALPHA = re.compile(r"([a-z0-9])([A-Z])")
+PATTERN_WHITESPACE = re.compile(r"\W")
+
+
+def snake_case(value):
+    s1 = PATTERN_LEADING_ALPHA.sub(r"\1_\2", value)
+    s1 = PATTERN_FOLLOWING_ALPHA.sub(r"\1_\2", s1).lower()
+    s1 = PATTERN_WHITESPACE.sub("_", s1)
+    s1 = s1.rstrip("_")
+    return PATTERN_DOUBLE_UNDERSCORE.sub("_", s1)
+
+
+def block_comment(comment, prefix="#"):
+    return "\n".join(f"{prefix} {line}".rstrip() for line in comment.split("\n"))
+
+
+def camel_case(value):
+    return "".join(x.title() for x in snake_case(value).split("_"))
+
+
+def untitle_case(value):
+    return value[0].lower() + value[1:]
+
+
+def schema_name(schema):
+    if not schema:
+        return None
+
+    if hasattr(schema, "__reference__"):
+        return schema.__reference__["$ref"].split("/")[-1]
+
+
+def given_variables(context):
+    """Return a list of variables using in given steps."""
+    return {key for values in context.get("_given", {}).values() for key in values}
+
+def escape_reserved_keyword(word):
+    """
+    Escape reserved language keywords like openapi generator does it
+    :param word: Word to escape
+    :return: The escaped word if it was a reserved keyword, the word unchanged otherwise
+    """
+    if word in KEYWORDS:
+        return f"_{word}"
+    return word
+
+
+def attribute_name(attribute):
+    return escape_reserved_keyword(snake_case(attribute))
+
+
+def format_value(value, quotes="'"):
+    if isinstance(value, str):
+        return f'{quotes}{value}{quotes}'
+    elif isinstance(value, bool):
+        return "true" if value else "false"
+    return value
+
+
+def format_parameters(kwargs, spec, replace_values=None, has_body=False):
+    parameters = ""
+    optional_spec = {}
+    opts = {}
+    for p in spec.get("parameters", []):
+        required = p.get("required", False)
+        k = snake_case(p["name"])
+        if required:
+            v = kwargs.pop(k)  # otherwise there is a missing required parameters
+            value = format_data_with_schema(
+                v["value"],
+                p["schema"],
+                replace_values=replace_values,
+            )
+            parameters += f"{value}, "
+        else:
+            optional_spec[k] = p
+
+    if optional_spec:
+        for k, v in kwargs.items():
+            k = snake_case(k)
+            value = format_data_with_schema(
+                v["value"],
+                optional_spec[k]["schema"],
+                replace_values=replace_values,
+            )
+            opts[escape_reserved_keyword(k)] = value
+
+        if opts:
+            parameters += "opts"
+
+    return parameters, opts
+
+
+def get_name(schema):
+
+    name = None
+    if hasattr(schema, "__reference__"):
+        name = schema.__reference__["$ref"].split("/")[-1]
+
+    return name
+
+
+@singledispatch
+def format_data_with_schema(
+    data,
+    schema,
+    name_prefix="",
+    replace_values=None,
+    default_name=None,
+):
+    name = get_name(schema)
+
+    if "enum" in schema and data not in schema["enum"]:
+        raise ValueError(f"{data} is not valid enum value {schema['enum']}")
+
+    if replace_values and data in replace_values:
+        warnings.warn(f"implement '{replace_values[data]}' with value {data}")
+        parameters = replace_values[data]
+        if schema.get("type") == "integer":
+            parameters = f"{parameters}.to_i"
+        elif schema.get("type") == "number":
+            parameters = f"{parameters}.to_f"
+    elif "enum" in schema:
+        parameters = schema["x-enum-varnames"][schema["enum"].index(data)]
+    else:
+        if schema.get("nullable") and data is None:
+            return "nil"
+        else:
+            formatter = {
+                "number": str,
+                "integer": str,
+                "boolean": lambda x: "true" if x else "false",
+                "string": repr,
+                None: repr,
+            }[schema.get("type")]
+
+            # TODO format date and datetime
+            parameters = formatter(data)
+
+    if "enum" in schema and name:
+        return f"{name_prefix}{name}::{parameters.upper()}"
+
+    if schema.get("type") == "string":
+        return f"{parameters}"
+
+    # NOTE we don't need named parameters for basic types except enums handled above
+    # if name:
+    #     return f"{name_prefix}{name}.new({{{parameters}}})"
+
+    return parameters
+
+
+@format_data_with_schema.register(list)
+def format_data_with_schema_list(
+    data,
+    schema,
+    name_prefix="",
+    replace_values=None,
+    default_name=None,
+):
+    name = get_name(schema)
+
+    parameters = ""
+    for d in data:
+        value = format_data_with_schema(
+            d,
+            schema["items"],
+            name_prefix=name_prefix,
+            replace_values=replace_values,
+            default_name=name,
+        )
+        parameters += f"{value},\n"
+    return f"[\n{parameters}]"
+
+
+@format_data_with_schema.register(dict)
+def format_data_with_schema_dict(
+    data,
+    schema,
+    name_prefix="",
+    replace_values=None,
+    default_name=None,
+):
+    name = get_name(schema)
+
+    parameters = ""
+    if "properties" in schema:
+        for k, v in data.items():
+            value = format_data_with_schema(
+                v,
+                schema["properties"][k],
+                name_prefix=name_prefix,
+                replace_values=replace_values,
+                default_name=name + camel_case(k) if name else None,
+            )
+            parameters += f"{escape_reserved_keyword(snake_case(k))}: {value},\n"
+
+    if "additionalProperties" in schema:
+        for k, v in data.items():
+            value = format_data_with_schema(
+                v,
+                schema["additionalProperties"],
+                name_prefix=name_prefix,
+                replace_values=replace_values,
+            )
+            parameters += f"{k}: {value}, "
+
+    if not name and "oneOf" not in schema:
+        if default_name:
+            name = default_name
+        else:
+            name = "dict"
+            warnings.warn(f"Unnamed schema {schema} for {data}")
+
+    if "oneOf" in schema:
+        matched = 0
+        for sub_schema in schema["oneOf"]:
+            try:
+                formatted = format_data_with_schema(
+                    data,
+                    sub_schema,
+                    name_prefix=name_prefix,
+                    replace_values=replace_values,
+                )
+                if matched == 0:
+                    # NOTE we do not support mixed schemas with oneOf
+                    # parameters += formatted
+                    parameters = formatted
+                    name = None
+                matched += 1
+            except (KeyError, ValueError) as e:
+                print(f"{e}")
+
+        if matched == 0:
+            raise ValueError(f"[{matched}] {data} is not valid for schema {name}")
+        elif matched > 1:
+            warnings.warn(f"[{matched}] {data} is not valid for schema {name}")
+
+    if name:
+        return f"{name_prefix}{name}.new({{\n{parameters}}})"
+
+    return parameters