aas-core-codegen 0.0.16__py3-none-any.whl

aas_core_codegen/typescript/main.py

@@ -0,0 +1,258 @@
+"""Generate TypeScript code to handle AAS models based on the meta-model."""
+from typing import TextIO
+
+from aas_core_codegen import run, intermediate
+from aas_core_codegen.typescript import (
+    aas_common as typescript_aas_common,
+    constants as typescript_constants,
+    jsonization as typescript_jsonization,
+    stringification as typescript_stringification,
+    structure as typescript_structure,
+    verification as typescript_verification,
+)
+
+
+def execute(context: run.Context, stdout: TextIO, stderr: TextIO) -> int:
+    """Generate the code."""
+    verified_ir_table, errors = typescript_structure.verify(
+        symbol_table=context.symbol_table
+    )
+
+    if errors is not None:
+        run.write_error_report(
+            message=f"Failed to verify the intermediate symbol table "
+            f"for generation of TypeScript code"
+            f"based on {context.model_path}",
+            errors=[context.lineno_columner.error_message(error) for error in errors],
+            stderr=stderr,
+        )
+        return 1
+
+    assert verified_ir_table is not None
+
+    unsupported_contracts_errors = (
+        intermediate.errors_if_contracts_for_functions_or_methods_defined(
+            verified_ir_table
+        )
+    )
+    if unsupported_contracts_errors is not None:
+        run.write_error_report(
+            message=f"We do not support pre and post-conditions and snapshots "
+            f"at the moment. Please notify the developers if you need this "
+            f"feature (based on meta-model {context.model_path})",
+            errors=[
+                context.lineno_columner.error_message(error)
+                for error in unsupported_contracts_errors
+            ],
+            stderr=stderr,
+        )
+        return 1
+
+    unsupported_methods_errors = (
+        intermediate.errors_if_non_implementation_specific_methods(verified_ir_table)
+    )
+    if unsupported_methods_errors is not None:
+        run.write_error_report(
+            message=f"We added some support for understood methods already and keep "
+            f"maintaining it as it is only a matter of time when we will "
+            f"introduce their transpilation. Introducing them after the fact "
+            f"would have been much more difficult.\n"
+            f"\n"
+            f"At the given moment, however, we deliberately focus only on "
+            f"implementation-specific methods. "
+            f"(based on meta-model {context.model_path})",
+            errors=[
+                context.lineno_columner.error_message(error)
+                for error in unsupported_methods_errors
+            ],
+            stderr=stderr,
+        )
+        return 1
+
+    # region Common
+    pth = context.output_dir / "common.ts"
+    pth.parent.mkdir(exist_ok=True)
+
+    try:
+        pth.write_text(typescript_aas_common.generate(), encoding="utf-8")
+    except Exception as exception:
+        run.write_error_report(
+            message=f"Failed to write the common TypeScript code to {pth}",
+            errors=[str(exception)],
+            stderr=stderr,
+        )
+        return 1
+
+    # endregion
+
+    # region Constants
+
+    code, errors = typescript_constants.generate(symbol_table=context.symbol_table)
+
+    if errors is not None:
+        run.write_error_report(
+            message=f"Failed to generate the constants in the TypeScript code "
+            f"based on {context.model_path}",
+            errors=[context.lineno_columner.error_message(error) for error in errors],
+            stderr=stderr,
+        )
+        return 1
+
+    assert code is not None
+
+    pth = context.output_dir / "constants.ts"
+    pth.parent.mkdir(exist_ok=True)
+
+    try:
+        pth.write_text(code, encoding="utf-8")
+    except Exception as exception:
+        run.write_error_report(
+            message=f"Failed to write the constants in the TypeScript code to {pth}",
+            errors=[str(exception)],
+            stderr=stderr,
+        )
+        return 1
+
+    # endregion
+
+    # region Jsonization
+
+    code, errors = typescript_jsonization.generate(
+        symbol_table=context.symbol_table, spec_impls=context.spec_impls
+    )
+
+    if errors is not None:
+        run.write_error_report(
+            message=f"Failed to generate the jsonization TypeScript code "
+            f"based on {context.model_path}",
+            errors=[context.lineno_columner.error_message(error) for error in errors],
+            stderr=stderr,
+        )
+        return 1
+
+    assert code is not None
+
+    pth = context.output_dir / "jsonization.ts"
+    pth.parent.mkdir(exist_ok=True)
+
+    try:
+        pth.write_text(code, encoding="utf-8")
+    except Exception as exception:
+        run.write_error_report(
+            message=f"Failed to write the jsonization TypeScript code to {pth}",
+            errors=[str(exception)],
+            stderr=stderr,
+        )
+        return 1
+
+    # endregion
+
+    # region Stringification
+
+    code, errors = typescript_stringification.generate(
+        symbol_table=context.symbol_table
+    )
+
+    if errors is not None:
+        run.write_error_report(
+            message=f"Failed to generate the stringification TypeScript code "
+            f"based on {context.model_path}",
+            errors=[context.lineno_columner.error_message(error) for error in errors],
+            stderr=stderr,
+        )
+        return 1
+
+    assert code is not None
+
+    pth = context.output_dir / "stringification.ts"
+    pth.parent.mkdir(exist_ok=True)
+
+    try:
+        pth.write_text(code, encoding="utf-8")
+    except Exception as exception:
+        run.write_error_report(
+            message=f"Failed to write the stringification TypeScript code to {pth}",
+            errors=[str(exception)],
+            stderr=stderr,
+        )
+        return 1
+
+    # endregion
+
+    # region Structure
+
+    code, errors = typescript_structure.generate(
+        symbol_table=verified_ir_table,
+        spec_impls=context.spec_impls,
+    )
+
+    if errors is not None:
+        run.write_error_report(
+            message=f"Failed to generate the structures in the TypeScript code "
+            f"based on {context.model_path}",
+            errors=[context.lineno_columner.error_message(error) for error in errors],
+            stderr=stderr,
+        )
+        return 1
+
+    assert code is not None
+
+    pth = context.output_dir / "types.ts"
+    try:
+        pth.write_text(code, encoding="utf-8")
+    except Exception as exception:
+        run.write_error_report(
+            message=f"Failed to write the TypeScript structures to {pth}",
+            errors=[str(exception)],
+            stderr=stderr,
+        )
+        return 1
+
+    # endregion
+
+    # region Verification
+
+    verify_errors = typescript_verification.verify(
+        spec_impls=context.spec_impls,
+        verification_functions=verified_ir_table.verification_functions,
+    )
+
+    if verify_errors is not None:
+        run.write_error_report(
+            message="Failed to verify for the generation of TypeScript verification code",
+            errors=verify_errors,
+            stderr=stderr,
+        )
+        return 1
+
+    code, errors = typescript_verification.generate(
+        symbol_table=verified_ir_table,
+        spec_impls=context.spec_impls,
+    )
+
+    if errors is not None:
+        run.write_error_report(
+            message=f"Failed to generate the verification TypeScript code "
+            f"based on {context.model_path}",
+            errors=[context.lineno_columner.error_message(error) for error in errors],
+            stderr=stderr,
+        )
+        return 1
+
+    assert code is not None
+
+    pth = context.output_dir / "verification.ts"
+    try:
+        pth.write_text(code, encoding="utf-8")
+    except Exception as exception:
+        run.write_error_report(
+            message=f"Failed to write the verification TypeScript code to {pth}",
+            errors=[str(exception)],
+            stderr=stderr,
+        )
+        return 1
+
+    # endregion
+
+    stdout.write(f"Code generated to: {context.output_dir}\n")
+    return 0

aas_core_codegen/typescript/naming.py

@@ -0,0 +1,189 @@
+"""Generate TypeScript identifiers based on the identifiers from the meta-model."""
+from typing import Union
+
+from icontract import require
+
+import aas_core_codegen.naming
+from aas_core_codegen import intermediate
+from aas_core_codegen.common import Identifier, assert_never
+
+
+# fmt: off
+@require(
+    lambda identifier: identifier[0].isupper(),
+    "Enumeration name must start with a capital letter"
+)
+# fmt: on
+def enum_name(identifier: Identifier) -> Identifier:
+    """
+    Generate a name for an enum based on its meta-model ``identifier``.
+
+    >>> enum_name(Identifier("Something"))
+    'Something'
+
+    >>> enum_name(Identifier("URL_to_something"))
+    'UrlToSomething'
+
+    >>> enum_name(Identifier("Something_to_URL"))
+    'SomethingToUrl'
+    """
+    return aas_core_codegen.naming.capitalized_camel_case(identifier)
+
+
+# fmt: off
+@require(
+    lambda identifier:
+    identifier[0].isupper(),
+    "Class names must start with a capital letter"
+)
+# fmt: on
+def class_name(identifier: Identifier) -> Identifier:
+    """
+    Generate a name for a class based on its meta-model ``identifier``.
+
+    >>> class_name(Identifier("Something"))
+    'Something'
+
+    >>> class_name(Identifier("URL_to_something"))
+    'UrlToSomething'
+
+    >>> class_name(Identifier("Something_to_URL"))
+    'SomethingToUrl'
+    """
+    return aas_core_codegen.naming.capitalized_camel_case(identifier)
+
+
+def name_of(
+    something: Union[
+        intermediate.Enumeration, intermediate.AbstractClass, intermediate.ConcreteClass
+    ]
+) -> Identifier:
+    """Dispatch the name based on the run-time type of ``something``."""
+    if isinstance(something, intermediate.Enumeration):
+        return enum_name(something.name)
+
+    elif isinstance(
+        something, (intermediate.AbstractClass, intermediate.ConcreteClass)
+    ):
+        return class_name(something.name)
+
+    else:
+        assert_never(something)
+
+
+def enum_literal_name(identifier: Identifier) -> Identifier:
+    """
+    Generate a name for an enum literal based on its meta-model ``identifier``.
+
+    >>> enum_literal_name(Identifier("something"))
+    'Something'
+
+    >>> enum_literal_name(Identifier("URL_to_something"))
+    'UrlToSomething'
+    """
+    return aas_core_codegen.naming.capitalized_camel_case(identifier)
+
+
+def constant_name(identifier: Identifier) -> Identifier:
+    """
+    Generate a name for a constant based on its meta-model ``identifier``.
+
+    >>> constant_name(Identifier("something"))
+    'SOMETHING'
+
+    >>> constant_name(Identifier("URL_to_something"))
+    'URL_TO_SOMETHING'
+    """
+    parts = identifier.split("_")
+    return Identifier("_".join(part.upper() for part in parts))
+
+
+# fmt: off
+@require(
+    lambda identifier:
+    identifier[0].isupper(),
+    "Interface names must start with a capital letter"
+)
+# fmt: on
+def interface_name(identifier: Identifier) -> Identifier:
+    """
+    Generate a name for a class based on its meta-model ``identifier``.
+
+    >>> interface_name(Identifier("Something"))
+    'ISomething'
+
+    >>> interface_name(Identifier("URL_to_something"))
+    'IUrlToSomething'
+
+    >>> interface_name(Identifier("Something_to_URL"))
+    'ISomethingToUrl'
+    """
+    return Identifier(f"I{aas_core_codegen.naming.capitalized_camel_case(identifier)}")
+
+
+def property_name(identifier: Identifier) -> Identifier:
+    """
+    Generate a name for a public property based on its meta-model ``identifier``.
+
+    >>> property_name(Identifier("something"))
+    'something'
+
+    >>> property_name(Identifier("something_to_URL"))
+    'somethingToUrl'
+
+    >>> property_name(Identifier("URL_to_something"))
+    'urlToSomething'
+    """
+    return aas_core_codegen.naming.lower_camel_case(identifier)
+
+
+def function_name(identifier: Identifier) -> Identifier:
+    """
+    Generate a name for a function from its meta-model ``identifier``.
+
+    >>> function_name(Identifier("do_something"))
+    'doSomething'
+
+    >>> function_name(Identifier("do_something_to_URL"))
+    'doSomethingToUrl'
+    """
+    return aas_core_codegen.naming.lower_camel_case(identifier)
+
+
+def method_name(identifier: Identifier) -> Identifier:
+    """
+    Generate a name for an instance method based on its meta-model ``identifier``.
+
+    >>> method_name(Identifier("do_something"))
+    'doSomething'
+
+    >>> method_name(Identifier("do_something_to_URL"))
+    'doSomethingToUrl'
+    """
+    return aas_core_codegen.naming.lower_camel_case(identifier)
+
+
+def argument_name(identifier: Identifier) -> Identifier:
+    """
+    Generate a name for an argument based on its meta-model ``identifier``.
+
+    >>> argument_name(Identifier("something"))
+    'something'
+
+    >>> argument_name(Identifier("something_to_URL"))
+    'somethingToUrl'
+    """
+    return aas_core_codegen.naming.lower_camel_case(identifier)
+
+
+def variable_name(identifier: Identifier) -> Identifier:
+    """
+    Generate a name for a variable based on its meta-model ``identifier``.
+
+    >>> variable_name(Identifier("something"))
+    'something'
+
+    >>> variable_name(Identifier("something_to_URL"))
+    'somethingToUrl'
+    """
+    return aas_core_codegen.naming.lower_camel_case(identifier)

aas_core_codegen/typescript/stringification/__init__.py

@@ -0,0 +1,4 @@
+"""Generate TypeScript code for de-serialization of enumerations from strings."""
+from aas_core_codegen.typescript.stringification import _generate
+
+generate = _generate.generate