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

aas_core_codegen/golang/reporting/_generate.py

@@ -0,0 +1,218 @@
+"""Generate the Golang code for reporting errors by including the code directly."""
+
+from icontract import ensure
+
+from aas_core_codegen.common import (
+    Stripped,
+)
+from aas_core_codegen.golang import (
+    common as golang_common,
+)
+from aas_core_codegen.golang.common import (
+    INDENT as I,
+    INDENT2 as II,
+    INDENT3 as III,
+    INDENT4 as IIII,
+    INDENT5 as IIIII,
+)
+
+
+# fmt: off
+@ensure(
+    lambda result:
+    result.endswith('\n'),
+    "Trailing newline mandatory for valid end-of-files"
+)
+# fmt: on
+def generate() -> str:
+    """Generate the Golang code for reporting errors."""
+    blocks = [
+        Stripped(
+            """\
+// Package reporting provides structures and functions for reporting of errors.
+package reporting"""
+        ),
+        golang_common.WARNING,
+        Stripped(
+            f"""\
+import (
+{I}"fmt"
+{I}"strings"
+{I}"strconv"
+)"""
+        ),
+        Stripped(
+            f"""\
+type NameSegment struct{{
+{I}Name string
+}}"""
+        ),
+        Stripped(
+            f"""\
+type IndexSegment struct{{
+{I}Index int
+}}"""
+        ),
+        Stripped(
+            f"""\
+type Path struct{{
+{I}// A segments is expected to be either a name segment or an index segment.
+{I}segments []interface{{}}
+{I}start int
+}}"""
+        ),
+        Stripped(
+            f"""\
+// Prepend the segment to the path.
+//
+// Grow segments exponentially if there is no place.
+func (p *Path) prepend(segment interface{{}}) {{
+{I}// See: https://en.wikipedia.org/wiki/Amortized_analysis#Dynamic_array
+{I}if len(p.segments) == 0 {{
+{II}p.segments = make([]interface{{}}, 1)
+{II}p.segments[0] = segment
+{II}p.start = 0
+{I}}} else if p.start > 0 {{
+{II}p.start--
+{II}p.segments[p.start] = segment
+{I}}} else {{
+{II}s := make([]interface{{}}, len(p.segments) * 2)
+{II}copy(s[len(p.segments):], p.segments)
+{II}p.start = len(p.segments) - 1
+{II}p.segments = s
+{II}p.segments[p.start] = segment
+{I}}}
+}}"""
+        ),
+        Stripped(
+            f"""\
+// Prepend the name segment to the path.
+func (p *Path) PrependName(segment *NameSegment) {{
+{I}p.prepend(segment)
+}}"""
+        ),
+        Stripped(
+            f"""\
+// Prepend the index segment to the path.
+func (p *Path) PrependIndex(segment *IndexSegment) {{
+{I}p.prepend(segment)
+}}"""
+        ),
+        Stripped(
+            f"""\
+// Apply the `callback` on each segment.
+//
+// The segment object is either a [NameSegment] or a [IndexSegment].
+func (p *Path) OverSegments(callback func(interface{{}})) {{
+{I}start := p.start
+{I}for i := start; i < len(p.segments); i++ {{
+{II}callback(p.segments[i])
+{I}}}
+}}"""
+        ),
+        Stripped(
+            f"""\
+// Translate the path to a JSON path.
+//
+// The name segments are expected to denote the names of the properties
+// in JSON property names, not Golang property names.
+func ToJSONPath(p *Path) string {{
+{I}var b strings.Builder
+{I}i := 0
+{I}p.OverSegments(func(s interface{{}}) {{
+{II}switch v := s.(type) {{
+{II}case *NameSegment:
+{III}if i == 0 {{
+{III}{I}b.WriteString(v.Name)
+{III}}} else {{
+{III}{I}b.WriteString(".")
+{III}{I}b.WriteString(v.Name)
+{III}}}
+{II}case *IndexSegment:
+{III}b.WriteString("[")
+{III}b.WriteString(strconv.Itoa(v.Index))
+{III}b.WriteString("]")
+{II}default:
+{III}panic(
+{III}{I}fmt.Sprintf(
+{III}{II}"Unexpected segment of type %T: %v",
+{III}{II}s, s,
+{III}{I}),
+{III})
+{II}}}
+
+{II}i++
+{I}}})
+{I}return b.String()
+}}"""
+        ),
+        Stripped(
+            f"""\
+// Translate the path to a Golang access path.
+//
+// The name segments are expected to denote the names of the properties
+// in Golang, not JSON property names.
+func ToGolangPath(p *Path) string {{
+{I}// NOTE(mristin):
+{I}// We re-use JSON path formatting as implementation, but introduce
+{I}// a separate function to signal to the reader in which form
+{I}// the name segments are expected (Golang property names instead
+{I}// of JSON property names).
+{I}return ToJSONPath(p)
+}}"""
+        ),
+        Stripped(
+            f"""\
+var replacerForXPath = strings.NewReplacer(
+{I}"/", "&#47;",
+{I}"<", "&lt;",
+{I}">", "&gt;",
+{I}"\\"", "&quot;",
+{I}"'", "&apos;",
+)"""
+        ),
+        Stripped(
+            f"""\
+// Escape special characters for XPath.
+func escapeForXPath(
+{I}text string,
+) string {{
+{I}return replacerForXPath.Replace(text)
+}}"""
+        ),
+        Stripped(
+            f"""\
+// Generate a relative XPath based on the path segments.
+//
+// Leave out the leading slash (`/`). This is helpful if we
+// want to embed the error report in a larger document with a prefix
+// *etc.*
+func ToRelativeXPath(
+{I}p *Path,
+) string {{
+{I}i := 0
+{I}var b strings.Builder
+{I}p.OverSegments(func(s interface{{}}) {{
+{II}if i > 0 {{
+{III}b.WriteString("/")
+{II}}}
+
+{II}switch v := s.(type) {{
+{III}case *NameSegment:
+{IIII}b.WriteString(escapeForXPath(v.Name))
+{III}case *IndexSegment:
+{IIII}b.WriteString(fmt.Sprintf("*[%d]", v.Index))
+{IIIII}{I}
+{III}default:
+{IIII}panic(fmt.Sprintf("Unexpected segment of type %T: %v", s, s))
+{II}}}
+{II}
+{II}i++
+{I}}})
+{I}return b.String()
+}}"""
+        ),
+        golang_common.WARNING,
+    ]
+
+    return "\n\n".join(blocks) + "\n"

aas_core_codegen/golang/stringification/__init__.py

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

aas_core_codegen/golang/stringification/_generate.py

@@ -0,0 +1,394 @@
+"""Generate Golang code for de/serialization of enumerations."""
+
+import io
+from typing import Tuple, Optional, List
+
+from icontract import ensure
+
+import aas_core_codegen.naming
+from aas_core_codegen import intermediate
+from aas_core_codegen.common import Error, Stripped, Identifier, indent_but_first_line
+from aas_core_codegen.golang import (
+    common as golang_common,
+    naming as golang_naming,
+)
+from aas_core_codegen.golang.common import (
+    INDENT as I,
+    INDENT2 as II,
+    INDENT3 as III,
+    INDENT4 as IIII,
+)
+
+
+def _generate_model_type_from_string(
+    symbol_table: intermediate.SymbolTable,
+) -> Stripped:
+    """Generate the function to translate our internal ``ModelType`` enum to string."""
+    # NOTE (mristin, 2023-06-06):
+    # Keep in sync with :func:`_generate_enum_from_string`. We copy/pasted and modified
+    # the code as creating an enumeration object out of model type turned out to be
+    # too tedious and *less* maintainable than copy/pasting. If you keep changing
+    # this part of the code base a lot, and have trouble keeping this function in sync
+    # with :func:`_generate_enum_from_string`, please consider re-factoring.
+
+    blocks = []  # type: List[Stripped]
+
+    # region From-string-map
+
+    items = []  # type: List[str]
+    for cls in symbol_table.concrete_classes:
+        literal_name = golang_naming.enum_literal_name(
+            Identifier("Model_type"), cls.name
+        )
+
+        literal_value = golang_common.string_literal(
+            aas_core_codegen.naming.json_model_type(cls.name)
+        )
+
+        items.append(f"{literal_value}: aastypes.{literal_name}")
+
+    from_str_map_name = golang_naming.private_constant_name(
+        Identifier("model_type_from_string_map")
+    )
+
+    items_joined = "\n".join(f"{item}," for item in items)
+
+    name = golang_naming.enum_name(Identifier("Model_type"))
+
+    blocks.append(
+        Stripped(
+            f"""\
+var {from_str_map_name} = map[string]aastypes.{name} {{
+{I}{indent_but_first_line(items_joined, I)}
+}}"""
+        )
+    )
+
+    # endregion
+
+    # region From-string-function
+    from_str_name = golang_naming.function_name(Identifier("model_type_from_string"))
+
+    blocks.append(
+        Stripped(
+            f"""\
+// Parse `text` as a string representation of [aastypes.{name}].
+//
+// If not ok, the literal result is undefined.
+func {from_str_name}(
+{I}text string,
+) (literal aastypes.{name}, ok bool) {{
+{I}literal, ok = {from_str_map_name}[text]
+{I}return
+}}"""
+        )
+    )
+
+    # endregion
+
+    return Stripped("\n\n".join(blocks))
+
+
+def _generate_model_type_to_string(symbol_table: intermediate.SymbolTable) -> Stripped:
+    """Generate the function to translate a string to our internal ``ModelType``."""
+    # NOTE (mristin, 2023-06-06):
+    # Keep in sync with :func:`_generate_enum_to_string`. We copy/pasted and modified
+    # the code as creating an enumeration object out of model type turned out to be
+    # too tedious and *less* maintainable than copy/pasting. If you keep changing
+    # this part of the code base a lot, and have trouble keeping this function in sync
+    # with :func:`_generate_enum_to_string`, please consider re-factoring.
+
+    blocks = []  # type: List[Stripped]
+
+    # region To-string-map
+
+    items = []  # type: List[str]
+    for cls in symbol_table.concrete_classes:
+        # NOTE (mristin, 2023-03-29):
+        # We assume that enumeration literals are specified using ``iota``.
+
+        literal_value = golang_common.string_literal(
+            aas_core_codegen.naming.json_model_type(cls.name)
+        )
+
+        items.append(literal_value)
+
+    to_str_array_name = golang_naming.private_constant_name(
+        Identifier("model_type_to_string_array")
+    )
+
+    items_joined = "\n".join(f"{item}," for item in items)
+
+    blocks.append(
+        Stripped(
+            f"""\
+var {to_str_array_name} = [...]string {{
+{I}{indent_but_first_line(items_joined, I)}
+}}"""
+        )
+    )
+
+    # endregion
+
+    # region To-string-function
+
+    to_str_name = golang_naming.function_name(Identifier("model_type_to_string"))
+
+    name = golang_naming.enum_name(Identifier("Model_type"))
+
+    blocks.append(
+        Stripped(
+            f"""\
+// Translate `value` from [aastypes.{name}] to a string.
+//
+// If the value is not valid, the OK is false and the string representation is
+// undefined.
+func {to_str_name}(
+{I}value aastypes.{name},
+) (result string, ok bool) {{
+{I}i := int(value)
+{I}ok =
+{II}i >= 0 &&
+{II}i < len({to_str_array_name})
+
+{I}if !ok {{
+{II}return
+{I}}}
+{I}result = {to_str_array_name}[value]
+{I}return
+}}"""
+        )
+    )
+
+    must_to_str_name = golang_naming.function_name(
+        Identifier("must_model_type_to_string")
+    )
+
+    blocks.append(
+        Stripped(
+            f"""\
+// Translate the `value` from [aastypes.{name}] to a string.
+//
+// Panic if the given value is invalid.
+func {must_to_str_name}(
+{I}value aastypes.{name},
+) string {{
+{I}result, ok := {to_str_name}(value)
+{I}if !ok {{
+{II}panic(
+{III}fmt.Sprintf(
+{IIII}"Invalid value of {name}: %v",
+{IIII}value,
+{III}),
+{II})
+{I}}}
+{I}return result
+}}"""
+        )
+    )
+
+    # endregion
+
+    return Stripped("\n\n".join(blocks))
+
+
+def _generate_enum_from_string(enumeration: intermediate.Enumeration) -> Stripped:
+    """Generate the functions for de-serializing enumeration from strings."""
+    blocks = []  # type: List[Stripped]
+
+    name = golang_naming.enum_name(enumeration.name)
+
+    # region From-string-map
+
+    items = []  # type: List[str]
+    for literal in enumeration.literals:
+        literal_name = golang_naming.enum_literal_name(enumeration.name, literal.name)
+        literal_value = golang_common.string_literal(literal.value)
+
+        items.append(f"{literal_value}: aastypes.{literal_name}")
+
+    from_str_map_name = golang_naming.private_constant_name(
+        Identifier(f"{enumeration.name}_from_string_map")
+    )
+
+    items_joined = "\n".join(f"{item}," for item in items)
+
+    blocks.append(
+        Stripped(
+            f"""\
+var {from_str_map_name} = map[string]aastypes.{name} {{
+{I}{indent_but_first_line(items_joined, I)}
+}}"""
+        )
+    )
+
+    # endregion
+
+    # region From-string-function
+    from_str_name = golang_naming.function_name(
+        Identifier(f"{enumeration.name}_from_string")
+    )
+
+    blocks.append(
+        Stripped(
+            f"""\
+// Parse `text` as a string representation of [aastypes.{name}].
+//
+// If not ok, the literal result is undefined.
+func {from_str_name}(
+{I}text string,
+) (literal aastypes.{name}, ok bool) {{
+{I}literal, ok = {from_str_map_name}[text]
+{I}return
+}}"""
+        )
+    )
+
+    # endregion
+
+    return Stripped("\n\n".join(blocks))
+
+
+def _generate_enum_to_string(enumeration: intermediate.Enumeration) -> Stripped:
+    """Generate the functions for serializing enumerations to strings."""
+    blocks = []  # type: List[Stripped]
+
+    name = golang_naming.enum_name(enumeration.name)
+
+    # region To-string-map
+
+    items = []  # type: List[str]
+    for literal in enumeration.literals:
+        # NOTE (mristin, 2023-03-29):
+        # We assume that enumeration literals are specified using ``iota``.
+        literal_value = golang_common.string_literal(literal.value)
+
+        items.append(literal_value)
+
+    to_str_array_name = golang_naming.private_constant_name(
+        Identifier(f"{enumeration.name}_to_string_array")
+    )
+
+    items_joined = "\n".join(f"{item}," for item in items)
+
+    blocks.append(
+        Stripped(
+            f"""\
+var {to_str_array_name} = [...]string {{
+{I}{indent_but_first_line(items_joined, I)}
+}}"""
+        )
+    )
+
+    # endregion
+
+    # region To-string-function
+
+    to_str_name = golang_naming.function_name(
+        Identifier(f"{enumeration.name}_to_string")
+    )
+
+    blocks.append(
+        Stripped(
+            f"""\
+// Translate `value` from [aastypes.{name}] to a string.
+//
+// If the value is not valid, the OK is false and the string representation is
+// undefined.
+func {to_str_name}(
+{I}value aastypes.{name},
+) (result string, ok bool) {{
+{I}i := int(value)
+{I}ok =
+{II}i >= 0 &&
+{II}i < len({to_str_array_name})
+
+{I}if !ok {{
+{II}return
+{I}}}
+{I}result = {to_str_array_name}[value]
+{I}return
+}}"""
+        )
+    )
+
+    must_to_str_name = golang_naming.function_name(
+        Identifier(f"must_{enumeration.name}_to_string")
+    )
+
+    blocks.append(
+        Stripped(
+            f"""\
+// Translate the `value` from [aastypes.{name}] to a string.
+//
+// Panic if the given value is invalid.
+func {must_to_str_name}(
+{I}value aastypes.{name},
+) string {{
+{I}result, ok := {to_str_name}(value)
+{I}if !ok {{
+{II}panic(
+{III}fmt.Sprintf(
+{IIII}"Invalid value of {name}: %v",
+{IIII}value,
+{III}),
+{II})
+{I}}}
+{I}return result
+}}"""
+        )
+    )
+
+    # endregion
+
+    return Stripped("\n\n".join(blocks))
+
+
+# fmt: off
+@ensure(lambda result: (result[0] is not None) ^ (result[1] is not None))
+@ensure(
+    lambda result:
+    not (result[0] is not None) or result[0].endswith('\n'),
+    "Trailing newline mandatory for valid end-of-files"
+)
+# fmt: on
+def generate(
+    symbol_table: intermediate.SymbolTable, repo_url: Stripped
+) -> Tuple[Optional[str], Optional[List[Error]]]:
+    """Generate the Golang code for the de/serialization of strings."""
+    aastypes_url_literal = golang_common.string_literal(f"{repo_url}/types")
+
+    blocks = [
+        Stripped(
+            """\
+// Package stringification converts enumerations from and to string representations.
+package stringification"""
+        ),
+        golang_common.WARNING,
+        Stripped(
+            f"""\
+import (
+{I}"fmt"
+{I}aastypes {aastypes_url_literal}
+)"""
+        ),
+        _generate_model_type_from_string(symbol_table=symbol_table),
+        _generate_model_type_to_string(symbol_table=symbol_table),
+    ]
+
+    for enum in symbol_table.enumerations:
+        blocks.append(_generate_enum_from_string(enumeration=enum))
+        blocks.append(_generate_enum_to_string(enumeration=enum))
+
+    blocks.append(golang_common.WARNING)
+
+    out = io.StringIO()
+    for i, block in enumerate(blocks):
+        if i > 0:
+            out.write("\n\n")
+
+        out.write(block)
+
+    out.write("\n")
+
+    return out.getvalue(), None

aas_core_codegen/golang/structure/__init__.py

@@ -0,0 +1,6 @@
+"""Generate Golang data structures to represent, iterate and transform an AAS."""
+
+from aas_core_codegen.golang.structure import _generate
+
+verify = _generate.verify
+generate = _generate.generate