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

aas_core_codegen/csharp/reporting/_generate.py

@@ -0,0 +1,266 @@
+"""Generate C# 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.csharp import (
+    common as csharp_common,
+)
+from aas_core_codegen.csharp.common import (
+    INDENT as I,
+    INDENT2 as II,
+    INDENT3 as III,
+    INDENT4 as IIII,
+    INDENT5 as IIIII,
+    INDENT6 as IIIIII,
+)
+
+
+# fmt: off
+@ensure(
+    lambda result:
+    result.endswith('\n'),
+    "Trailing newline mandatory for valid end-of-files"
+)
+# fmt: on
+def generate(namespace: csharp_common.NamespaceIdentifier) -> str:
+    """
+    Generate the C# code for reporting errors.
+
+    The ``namespace`` defines the AAS C# namespace.
+    """
+    blocks = [
+        Stripped(
+            f"""\
+/// <summary>
+/// Capture a path segment of a value in a model.
+/// </summary>
+public abstract class Segment
+{{
+{I}// Intentionally empty.
+}}"""
+        ),
+        Stripped(
+            f"""\
+public class NameSegment : Segment
+{{
+{I}public readonly string Name;
+{I}public NameSegment(string name)
+{I}{{
+{II}Name = name;
+{I}}}
+}}"""
+        ),
+        Stripped(
+            f"""\
+public class IndexSegment : Segment
+{{
+{I}public readonly int Index;
+{I}public IndexSegment(int index)
+{I}{{
+{II}Index = index;
+{I}}}
+}}"""
+        ),
+        Stripped(
+            f"""\
+private static readonly System.Text.RegularExpressions.Regex VariableNameRe = (
+{I}new System.Text.RegularExpressions.Regex(
+{II}@"^[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"""\
+/// <summary>
+/// Generate a JSON Path based on the path segments.
+/// </summary>
+/// <remarks>
+/// See, for example, this page for more information on JSON path:
+/// https://support.smartbear.com/alertsite/docs/monitors/api/endpoint/jsonpath.html
+/// </remarks>
+public static string GenerateJsonPath(
+{I}ICollection<Segment> segments)
+{{
+{I}var parts = new List<string>(segments.Count);
+{I}int i = 0;
+{I}foreach (var segment in segments)
+{I}{{
+{II}string? part;
+{II}switch (segment)
+{II}{{
+{III}case NameSegment nameSegment:
+{IIII}if (VariableNameRe.IsMatch(nameSegment.Name))
+{IIII}{{
+{IIIII}part = (i == 0) ? nameSegment.Name : $".{{nameSegment.Name}}";
+{IIII}}}
+{IIII}else
+{IIII}{{
+{IIIII}string escaped = nameSegment.Name
+{IIIIII}.Replace("\\\\", "\\\\\\\\")
+{IIIIII}.Replace("\\"", "\\\\\\"")
+{IIIIII}.Replace("\\b", "\\\\b")
+{IIIIII}.Replace("\\f", "\\\\f")
+{IIIIII}.Replace("\\n", "\\\\n")
+{IIIIII}.Replace("\\r", "\\\\r")
+{IIIIII}.Replace("\\t", "\\\\t");
+{IIIII}part = $"[\\"{{escaped}}\\"]";
+{IIII}}}
+{IIII}break;
+{III}case IndexSegment indexSegment:
+{IIII}part = $"[{{indexSegment.Index}}]";
+{IIII}break;
+{III}default:
+{IIII}throw new System.InvalidOperationException(
+{IIIII}$"Unexpected segment type: {{segment.GetType()}}");
+{II}}}
+{II}parts.Add(part);
+{II}i++;
+{I}}}
+{I}return string.Join("", parts);
+}}"""
+        ),
+        Stripped(
+            f"""\
+/// <summary>
+/// Escape special characters for XPath.
+/// </summary>
+private static string EscapeForXPath(
+    string text)
+{{
+{I}// Mind the order, as we need to replace '&' first.
+{I}//
+{I}// For some benchmarks, see:
+{I}// https://stackoverflow.com/questions/1321331/replace-multiple-string-elements-in-c-sharp
+{I}return (
+{II}text
+{III}// Even though ampersand, less-then etc. can not occur in valid element names,
+{III}// we escape them here for easier debugging and better bug reports.
+{III}.Replace("&", "&amp;")
+{III}.Replace("/", "&#47;")
+{III}.Replace("<", "&lt;")
+{III}.Replace(">", "&gt;")
+{III}.Replace("\\"", "&quot;")
+{III}.Replace("'", "&apos;")
+{I});
+}}"""
+        ),
+        Stripped(
+            f"""\
+/// <summary>
+/// Generate a relative XPath based on the path segments.
+/// </summary>
+/// <remarks>
+/// This method leaves out the leading slash ('/'). This is helpful if
+/// to embed the error report in a larger document with a prefix etc.
+/// </remarks>
+public static string GenerateRelativeXPath(
+{I}ICollection<Segment> segments)
+{{
+{I}var parts = new List<string>(segments.Count);
+{I}foreach (var segment in segments)
+{I}{{
+{II}string? part;
+{II}switch (segment)
+{II}{{
+{III}case NameSegment nameSegment:
+{IIII}part = EscapeForXPath(nameSegment.Name);
+{IIII}break;
+{III}case IndexSegment indexSegment:
+{IIII}part = $"*[{{indexSegment.Index}}]";
+{IIII}break;
+{III}default:
+{IIII}throw new System.InvalidOperationException(
+{IIIII}$"Unexpected segment type: {{segment.GetType()}}");
+{II}}}
+{II}parts.Add(part);
+{I}}}
+{I}return string.Join("/", parts);
+}}"""
+        ),
+        Stripped(
+            f"""\
+/// <summary>
+/// Represent an error during the deserialization or the verification.
+/// </summary>
+public class Error
+{{
+{I}[CodeAnalysis.SuppressMessage("ReSharper", "InconsistentNaming")]
+{I}internal readonly LinkedList<Segment> _pathSegments = new LinkedList<Segment>();
+{I}public readonly string Cause;
+{I}public ICollection<Segment> PathSegments => _pathSegments;
+{I}public Error(string cause)
+{I}{{
+{II}Cause = cause;
+{I}}}
+
+{I}public void PrependSegment(Segment segment)
+{I}{{
+{II}_pathSegments.AddFirst(segment);
+{I}}}
+}}"""
+        ),
+    ]
+
+    writer = io.StringIO()
+    writer.write(
+        f"""\
+namespace {namespace}
+{{
+{I}/// <summary>
+{I}/// Provide reporting for de/serialization and verification.
+{I}/// </summary>
+{I}public static class Reporting
+{I}{{
+"""
+    )
+
+    for i, deserialize_block in enumerate(blocks):
+        if i > 0:
+            writer.write("\n\n")
+
+        writer.write(textwrap.indent(deserialize_block, II))
+
+    writer.write(f"\n{I}}}  // public static class Reporting")
+    writer.write(f"\n}}  // namespace {namespace}")
+
+    using_directives = []  # type: List[Stripped]
+    using_directives.extend(
+        csharp_common.generate_using_aas_directive_if_necessary(namespace)
+    )
+
+    using_directives.append(
+        Stripped(
+            """\
+using CodeAnalysis = System.Diagnostics.CodeAnalysis;
+
+using System.Collections.Generic;  // can't alias"""
+        )
+    )
+
+    # pylint: disable=line-too-long
+    blocks = [
+        csharp_common.WARNING,
+        Stripped("\n".join(using_directives)),
+        Stripped(writer.getvalue()),
+        csharp_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/csharp/stringification/__init__.py

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

aas_core_codegen/csharp/stringification/_generate.py

@@ -0,0 +1,243 @@
+"""Generate C# code for de/serialization based on the intermediate representation."""
+
+import io
+import textwrap
+import xml.sax.saxutils
+from typing import Tuple, Optional, List
+
+from icontract import ensure
+
+from aas_core_codegen import intermediate
+from aas_core_codegen.common import Error, Stripped, Identifier
+from aas_core_codegen.csharp import common as csharp_common, naming as csharp_naming
+from aas_core_codegen.csharp.common import INDENT as I, INDENT2 as II, INDENT3 as III
+
+
+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 = csharp_naming.enum_name(enumeration.name)
+
+    # region To-string-map
+
+    # NOTE (mristin, 2022-05-05):
+    # We make the property look "public" by the name since it is a static and read-only.
+    to_str_map_name = csharp_naming.property_name(
+        Identifier(f"{enumeration.name}_to_string")
+    )
+
+    to_str_map_writer = io.StringIO()
+    to_str_map_writer.write(
+        f"""\
+private static readonly Dictionary<Aas.{name}, string> {to_str_map_name} = (
+{I}new Dictionary<Aas.{name}, string>()
+{I}{{
+"""
+    )
+
+    for i, literal in enumerate(enumeration.literals):
+        literal_name = csharp_naming.enum_literal_name(literal.name)
+        to_str_map_writer.write(
+            f"{II}{{ Aas.{name}.{literal_name}, "
+            f"{csharp_common.string_literal(literal.value)} }}"
+        )
+
+        if i < len(enumeration.literals) - 1:
+            to_str_map_writer.write(",")
+
+        to_str_map_writer.write("\n")
+
+    to_str_map_writer.write(f"{I}}});")
+
+    blocks.append(Stripped(to_str_map_writer.getvalue()))
+
+    # endregion
+
+    # region To-string-method
+
+    to_str_name = csharp_naming.method_name(Identifier("to_string"))
+
+    to_str_writer = io.StringIO()
+    to_str_writer.write(
+        f"""\
+/// <summary>
+/// Retrieve the string representation of <paramref name="that" />.
+/// </summary>
+/// <remarks>
+/// If <paramref name="that" /> is not a valid literal, return <c>null</c>.
+/// </remarks>
+public static string? {to_str_name}(Aas.{name}? that)
+{{
+{I}if (!that.HasValue)
+{I}{{
+{II}return null;
+{I}}}
+{I}else
+{I}{{
+{II}if ({to_str_map_name}.TryGetValue(that.Value, out string? value))
+{II}{{
+{III}return value;
+{II}}}
+{II}else
+{II}{{
+{III}return null;
+{II}}}
+{I}}}
+}}"""
+    )
+
+    blocks.append(Stripped(to_str_writer.getvalue()))
+
+    # endregion
+
+    # region From-string-map
+
+    from_str_map_name = csharp_naming.private_property_name(
+        Identifier(f"{enumeration.name}_from_string")
+    )
+
+    from_str_map_writer = io.StringIO()
+    from_str_map_writer.write(
+        f"""\
+[CodeAnalysis.SuppressMessage("ReSharper", "InconsistentNaming")]
+private static readonly Dictionary<string, Aas.{name}> {from_str_map_name} = (
+{I}new Dictionary<string, Aas.{name}>()
+{I}{{
+"""
+    )
+
+    for i, literal in enumerate(enumeration.literals):
+        literal_name = csharp_naming.enum_literal_name(literal.name)
+        from_str_map_writer.write(
+            f"{II}{{ {csharp_common.string_literal(literal.value)}, "
+            f"Aas.{name}.{literal_name} }}"
+        )
+
+        if i < len(enumeration.literals) - 1:
+            from_str_map_writer.write(",")
+
+        from_str_map_writer.write("\n")
+
+    from_str_map_writer.write(f"{I}}});")
+
+    blocks.append(Stripped(from_str_map_writer.getvalue()))
+
+    # endregion
+
+    # region From-string-method
+
+    from_str_name = csharp_naming.method_name(
+        Identifier(f"{enumeration.name}_from_string")
+    )
+
+    from_str_writer = io.StringIO()
+    from_str_writer.write(
+        f"""\
+/// <summary>
+/// Parse the string representation of <see cref={xml.sax.saxutils.quoteattr(name)} />.
+/// </summary>
+/// <remarks>
+/// If <paramref name="text" /> is not a valid string representation
+/// of a literal of <see cref={xml.sax.saxutils.quoteattr(name)} />,
+/// return <c>null</c>.
+/// </remarks>
+public static Aas.{name}? {from_str_name}(string text)
+{{
+{I}if ({from_str_map_name}.TryGetValue(text, out {name} value))
+{I}{{
+{II}return value;
+{I}}}
+{I}else
+{I}{{
+{II}return null;
+{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, namespace: csharp_common.NamespaceIdentifier
+) -> Tuple[Optional[str], Optional[List[Error]]]:
+    """
+    Generate the C# code for the general serialization.
+
+    The ``namespace`` defines the AAS C# namespace.
+    """
+    using_directives = []  # type: List[Stripped]
+    using_directives.extend(
+        csharp_common.generate_using_aas_directive_if_necessary(namespace)
+    )
+
+    using_directives.append(
+        Stripped(
+            """\
+using CodeAnalysis = System.Diagnostics.CodeAnalysis;
+
+using System.Collections.Generic;  // can't alias"""
+        )
+    )
+
+    blocks = [
+        csharp_common.WARNING,
+        Stripped("\n".join(using_directives)),
+    ]
+
+    stringification_blocks = []  # type: List[Stripped]
+
+    for enum in symbol_table.enumerations:
+        stringification_blocks.append(
+            _generate_enum_to_and_from_string(enumeration=enum)
+        )
+
+    writer = io.StringIO()
+    writer.write(
+        f"""\
+namespace {namespace}
+{{
+{I}public static class Stringification
+{I}{{
+"""
+    )
+
+    for i, stringification_block in enumerate(stringification_blocks):
+        if i > 0:
+            writer.write("\n\n")
+
+        writer.write(textwrap.indent(stringification_block, II))
+
+    writer.write(f"\n{I}}}  // public static class Stringification")
+    writer.write(f"\n}}  // namespace {namespace}")
+
+    blocks.append(Stripped(writer.getvalue()))
+
+    blocks.append(csharp_common.WARNING)
+
+    out = io.StringIO()
+    for i, block in enumerate(blocks):
+        if i > 0:
+            out.write("\n\n")
+
+        assert not block.startswith("\n")
+        assert not block.endswith("\n")
+        out.write(block)
+
+    out.write("\n")
+
+    return out.getvalue(), None

aas_core_codegen/csharp/structure/__init__.py

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