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

aas_core_codegen/java/reporting/_generate.py

@@ -0,0 +1,248 @@
+"""Generate Java code for reporting errors by including the code directly."""
+
+import io
+import textwrap
+from typing import List
+
+from icontract import ensure
+
+from aas_core_codegen.common import (
+    Stripped,
+)
+from aas_core_codegen.java import (
+    common as java_common,
+)
+from aas_core_codegen.csharp.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(package: java_common.PackageIdentifier) -> str:
+    """
+    Generate the Java code for reporting errors.
+
+    The ``package`` defines the root Java package.
+    """
+
+    blocks = [
+        Stripped(
+            f"""\
+/**
+ * Capture a path segment of a value in a model.
+ */
+public static abstract class Segment {{
+{I}// Intentionally empty.
+}}"""
+        ),
+        Stripped(
+            f"""\
+public static class NameSegment extends Segment {{
+{I}private final String name;
+{I}public NameSegment(String name) {{
+{II}this.name = Objects.requireNonNull(name,
+{III}"Argument \\"name\\" must be non-null.");
+{I}}}
+{I}public String getName(){{
+{II}return name;
+{I}}}
+}}"""
+        ),
+        Stripped(
+            f"""\
+public static class IndexSegment extends Segment{{
+{I}private final Integer index;
+{I}public IndexSegment(int index) {{
+{II}this.index = index;
+{I}}}
+{I}public Integer getIndex(){{
+{II}return index;
+{I}}}
+}}"""
+        ),
+        Stripped(
+            """\
+private static final Pattern variableNameRe = Pattern.compile("^[a-zA-Z_][a-zA-Z_0-9]*$");"""
+        ),
+        # We have to indent a lot, so we do not use textwrap.dedent for better
+        # readability.
+        Stripped(
+            f"""\
+/**
+ * Generate a JSON Path based on the path segments.
+ *
+ * <p>See, for example, this page for more information on JSON path:
+ * <a href="https://support.smartbear.com/alertsite/docs/monitors/api/endpoint/jsonpath.html"
+ * >https://support.smartbear.com/alertsite/docs/monitors/api/endpoint/jsonpath.html</a>
+ */
+public static String generateJsonPath(Collection<Segment> segments) {{
+{I}ArrayList<String> parts = new ArrayList<>(segments.size());
+{I}int i = 0;
+
+{I}for (Segment segment : segments) {{
+{II}String part;
+
+{II}if (segment instanceof NameSegment) {{
+{III}NameSegment nameSegment = (NameSegment) segment;
+{III}Matcher m = variableNameRe.matcher(nameSegment.getName());
+
+{III}if (m.matches()) {{
+{IIII}part = (i == 0) ? nameSegment.getName() : "." + nameSegment.getName();
+{III}}} else {{
+{IIII}String escaped = nameSegment.getName()
+{IIIII}.replace("\\t", "\\\\t")
+{IIIII}.replace("\\b", "\\\\b")
+{IIIII}.replace("\\n", "\\\\n")
+{IIIII}.replace("\\r", "\\\\r")
+{IIIII}.replace("\\f", "\\\\f")
+{IIIII}.replace("\\"", "\\\\\\"")
+{IIIII}.replace("\\\\", "\\\\\\\\");
+
+{IIII}part = "[\\"" + escaped + "\\"]";
+{III}}}
+{II}}} else if (segment instanceof IndexSegment) {{
+{III}IndexSegment indexSegment = (IndexSegment) segment;
+{III}part = "[" + indexSegment.getIndex() + "]";
+{II}}} else {{
+{III}throw new RuntimeException(
+{IIII}"Unexpected segment type: " + segment.getClass().getSimpleName()
+{III});
+{II}}}
+
+{II}parts.add(part);
+{II}i++;
+{I}}}
+{I}return String.join("", parts);
+}}"""
+        ),
+        Stripped(
+            f"""\
+/**
+ * Escape special characters for XPath.
+ */
+private static String escapeForXPath(String text) {{
+return text
+{II}.replace("&", "&amp;")
+{II}.replace("/", "&#47;")
+{II}.replace("<", "&lt;")
+{II}.replace(">", "&gt;")
+{II}.replace("\\"", "&quot;")
+{II}.replace("'", "&apos;");
+}}"""
+        ),
+        Stripped(
+            f"""\
+/**
+ * Generate a relative XPath based on the path segments.
+ *
+ * <p>This method leaves out the leading slash ('/'). This is helpful if
+ * to embed the error report in a larger document with a prefix etc.
+ */
+public static String generateRelativeXPath(Collection<Segment> segments) {{
+{I}final List<String> parts = new ArrayList<>();
+{I}segments.forEach(segment -> {{
+{II}String part;
+{II}if (segment instanceof NameSegment) {{
+{III}final NameSegment nameSegment = ((NameSegment) segment);
+{III}final String name = nameSegment.getName();
+{III}part = escapeForXPath(name);
+{II}}} else if (segment instanceof IndexSegment) {{
+{III}final IndexSegment indexSegment = ((IndexSegment) segment);
+{III}final int index = indexSegment.getIndex();
+{III}part = "*[" + index + "]";
+{II}}} else {{
+{III}throw new IllegalArgumentException("Unexpected segment type: " +
+{IIII}segment.getClass().getSimpleName());
+{II}}}
+{II}parts.add(part);
+{I}}});
+{I}return String.join("/", parts);
+}}"""
+        ),
+        Stripped(
+            f"""\
+/**
+ * Represent an error during the deserialization or the verification.
+ */
+public static class Error {{
+{I}private final Deque<Segment> pathSegments = new LinkedList<>();
+{I}private final String cause;
+
+{I}public Error(String cause) {{
+{II}this.cause = cause;
+{I}}}
+
+{I}public void prependSegment(Segment segment) {{
+{II}pathSegments.addFirst(segment);
+{I}}}
+
+{I}public String getCause() {{
+{II}return cause;
+{I}}}
+
+{I}public Collection<Segment> getPathSegments() {{
+{II}return pathSegments;
+{I}}}
+}}"""
+        ),
+    ]  # type: List[Stripped]
+
+    writer = io.StringIO()
+    writer.write(
+        f"""\
+package {package}.reporting;
+
+import java.util.ArrayList;
+import java.util.Deque;
+import java.util.Collections;
+import java.util.Collection;
+import java.util.List;
+import java.util.LinkedList;
+import java.util.Objects;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * Provide reporting for de/serialization and verification.
+ */
+public class Reporting
+{{
+"""
+    )
+
+    for i, deserialize_block in enumerate(blocks):
+        if i > 0:
+            writer.write("\n\n")
+
+        writer.write(textwrap.indent(deserialize_block, I))
+
+    writer.write("\n}")
+
+    blocks = [
+        java_common.WARNING,
+        Stripped(writer.getvalue()),
+        java_common.WARNING,
+    ]
+
+    writer = io.StringIO()
+    for i, block in enumerate(blocks):
+        if i > 0:
+            writer.write("\n\n")
+
+        assert not block.startswith("\n")
+        assert not block.endswith("\n")
+        writer.write(block)
+
+    writer.write("\n")
+
+    return writer.getvalue()

aas_core_codegen/java/stringification/__init__.py

@@ -0,0 +1,4 @@
+"""Generate Java code for de/serialization of enumerations."""
+from aas_core_codegen.java.stringification import _generate
+
+generate = _generate.generate

aas_core_codegen/java/stringification/_generate.py

@@ -0,0 +1,212 @@
+"""Generate Java code for de/serialization based on the intermediate representation."""
+
+import io
+from typing import Tuple, Optional, List
+
+from icontract import ensure
+
+from aas_core_codegen import intermediate
+from aas_core_codegen.common import (
+    indent_but_first_line,
+    Error,
+    Stripped,
+    Identifier,
+)
+from aas_core_codegen.java import (
+    common as java_common,
+    naming as java_naming,
+)
+from aas_core_codegen.java.common import (
+    INDENT as I,
+    INDENT2 as II,
+)
+
+
+def _generate_enum_to_and_from_string(
+    enumeration: intermediate.Enumeration,
+) -> Stripped:
+    """Generate the methods for de/serializing enumeration from/to a string."""
+    blocks = []  # type: List[Stripped]
+
+    name = java_naming.enum_name(enumeration.name)
+
+    # region To-string-map
+
+    enum_to_string_blocks = []  # type: List[Stripped]
+
+    for literal in enumeration.literals:
+        literal_name = java_naming.enum_literal_name(literal.name)
+
+        literal_string = java_common.string_literal(literal.value)
+
+        enum_to_string_blocks.append(
+            Stripped(f"""temp.put({name}.{literal_name}, {literal_string});""")
+        )
+
+    enum_to_string_mapping = "\n".join(enum_to_string_blocks)
+
+    to_str_map_name = java_naming.property_name(
+        Identifier(f"{enumeration.name}_to_string")
+    )
+
+    to_str_map = Stripped(
+        f"""\
+private static final Map<{name}, String> {to_str_map_name};
+static {{
+{I}final Map<{name}, String> temp = new HashMap<>();
+
+{I}{indent_but_first_line(enum_to_string_mapping, I)}
+
+{I}if (!temp.keySet().containsAll(Arrays.asList({name}.values()))) {{
+{II}throw new IllegalStateException("Unmapped {name}");
+{I}}}
+
+{I}{to_str_map_name} = Collections.unmodifiableMap(temp);
+}}"""
+    )
+
+    blocks.append(to_str_map)
+
+    # endregion
+
+    # region To-string-method
+
+    to_str_name = java_naming.method_name(Identifier("to_string"))
+
+    to_str_writer = io.StringIO()
+    to_str_writer.write(
+        f"""\
+/**
+ * Retrieve the string representation of {{@code that}}.
+ *
+ * <p>If {{@code that}} is not a valid literal, return {{@code Optional#empty()}}.
+ */
+public static Optional<String> {to_str_name}({name} that)
+{{
+{I}return Optional.ofNullable(that).map({to_str_map_name}::get);
+}}"""
+    )
+
+    blocks.append(Stripped(to_str_writer.getvalue()))
+
+    # endregion
+
+    # region From-string-map
+
+    string_to_enum_blocks = []  # type: List[Stripped]
+
+    for literal in enumeration.literals:
+        literal_name = java_naming.enum_literal_name(literal.name)
+
+        literal_string = java_common.string_literal(literal.value)
+
+        string_to_enum_blocks.append(
+            Stripped(f"""temp.put({literal_string}, {name}.{literal_name});""")
+        )
+
+    string_to_enum_mapping = "\n".join(string_to_enum_blocks)
+
+    from_str_map_name = java_naming.private_property_name(
+        Identifier(f"{enumeration.name}_from_string")
+    )
+
+    from_str_map = Stripped(
+        f"""\
+private static final Map<String, {name}> {from_str_map_name};
+static {{
+{I}final Map<String, {name}> temp = new HashMap<>();
+
+{I}{indent_but_first_line(string_to_enum_mapping, I)}
+
+{I}if (!temp.values().containsAll(Arrays.asList({name}.values()))) {{
+{II}throw new IllegalStateException("Unmapped {name}");
+{I}}}
+
+{I}{from_str_map_name} = Collections.unmodifiableMap(temp);
+}}"""
+    )
+
+    blocks.append(from_str_map)
+
+    # endregion
+
+    # region From-string-method
+
+    from_str_name = java_naming.method_name(
+        Identifier(f"{enumeration.name}_from_string")
+    )
+
+    from_str_writer = io.StringIO()
+    from_str_writer.write(
+        f"""\
+/**
+ * Parse the string representation of {{@link {name}}}.
+ *
+ * <p>If {{@code text}} is not a valid string representation
+ * of a literal of {{@link {name}}},
+ * return {{@code Optional#empty()}}.
+ */
+public static Optional<{name}> {from_str_name}(String text)
+{{
+{I}{name} value = {from_str_name}.get(text);
+{I}if (value == null) {{
+{II}return Optional.empty();
+{I}}} else {{
+{II}return Optional.of(value);
+{I}}}
+}}"""
+    )
+
+    blocks.append(Stripped(from_str_writer.getvalue()))
+
+    # 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, package: java_common.PackageIdentifier
+) -> Tuple[Optional[str], Optional[List[Error]]]:
+    """
+    Generate the Java code for the general serialization.
+
+    The ``package`` defines the root Java package.
+    """
+    stringification_blocks = []  # type: List[Stripped]
+
+    for enum in symbol_table.enumerations:
+        stringification_blocks.append(
+            _generate_enum_to_and_from_string(enumeration=enum)
+        )
+
+    stringification_code = Stripped("\n\n".join(stringification_blocks))
+
+    code = Stripped(
+        f"""\
+{java_common.WARNING}
+
+package {package}.stringification;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Optional;
+import {package}.types.enums.*;
+
+public class Stringification {{
+{I}{indent_but_first_line(stringification_code, I)}
+}}
+
+{java_common.WARNING}"""
+    )
+
+    return f"{code}\n", None

aas_core_codegen/java/structure/__init__.py

@@ -0,0 +1,6 @@
+"""Generate Java data structures to represent an AAS."""
+
+from aas_core_codegen.java.structure import _generate
+
+verify = _generate.verify
+generate = _generate.generate