shacl2code 0.0.14__tar.gz → 0.0.16__tar.gz

{shacl2code-0.0.14 → shacl2code-0.0.16}/.github/workflows/coverage-generate.yaml

@@ -25,6 +25,9 @@ jobs:
         uses: actions/setup-python@v4
         with:
           python-version: "3.11"
+      - name: Install dependencies
+        run: |
+          sudo apt install -y build-essential doxygen graphviz
       - name: Install package
         run: |
           pip install -e .[dev]

{shacl2code-0.0.14 → shacl2code-0.0.16}/.github/workflows/test.yaml

@@ -31,6 +31,7 @@ jobs:
           python -m pip install --upgrade pip
           pip install build
           npm install -g jsonld-cli
+          sudo apt install -y build-essential doxygen graphviz
       - name: Build package
         run: |
           python -m build

{shacl2code-0.0.14 → shacl2code-0.0.16}/PKG-INFO

@@ -1,12 +1,11 @@
 Metadata-Version: 2.3
 Name: shacl2code
-Version: 0.0.14
+Version: 0.0.16
 Summary: Convert SHACL model file to code bindings
 Project-URL: Homepage, https://github.com/JPEWdev/shacl2code
 Project-URL: Repository, https://github.com/JPEWdev/shacl2code.git
 Project-URL: Issues, https://github.com/JPEWdev/shacl2code/issues
 Author-email: Joshua Watt <JPEWhacker@gmail.com>
-License-File: LICENSE
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
@@ -183,7 +182,36 @@ from an extensible type.
 By default, classes generated by `shacl2code` are all instantiable (i.e. they
 can be created). In some instances, it may be desirable to declare a class as
 abstract (meaning that it cannot be instantiated, but non-abstract derived
-classes can). This can be done with the boolean `isAbstract` property. For
+classes can). There are several ways of marking a class as abstract listed
+below, in order of preference (with the most preferred being first).
+
+#### SHACL Validated Abstract Classes
+
+A class can be prevented from being directly instantiated using SHACL by adding
+a constraint on the shape that it cannot be of its own type. This can be done
+with the following turtle:
+
+```ttl
+
+<MyClass> a owl:Class, sh:NodeShape ;
+    # SHACL to prevent a class from being instansiated as this exact type
+    sh:property [
+        sh:path rdf:type ;
+        sh:not [ sh:hasValue <MyClass> ]
+    ] .
+
+```
+
+`shacl2code` will detect this pattern and generate abstract bindings for
+`MyClass`.
+
+This method is most preferred, since it is enforced by SHACL and not just
+`shacl2code` bindings
+
+#### shacl2code Annotation
+
+`shacl2code` has a custom annotation that can be used to mark a class as
+abstract. This can be done with the boolean `isAbstract` property. For
 example, the following turtle will declare a class as abstract:
 
 ```ttl
@@ -196,9 +224,10 @@ example, the following turtle will declare a class as abstract:
 The `isAbstract` property is _not_ inherited by derived classes, so any derived
 classes are automatically concrete unless they indicate otherwise.
 
-Note that for compatibility reasons, it is also possible to define a class as
-abstract by declaring it to be of type: `http://spdx.invalid./AbstractClass`,
-but this is not preferred.
+#### SPDX Abstract Class Parent
+
+It is also possible to define a class as abstract by declaring it to be of
+type: `http://spdx.invalid./AbstractClass`, but this is not preferred.
 
 [pytest]: https://www.pytest.org
 [pytest-cov]: https://pytest-cov.readthedocs.io/en/latest/

{shacl2code-0.0.14 → shacl2code-0.0.16}/README.md

@@ -153,7 +153,36 @@ from an extensible type.
 By default, classes generated by `shacl2code` are all instantiable (i.e. they
 can be created). In some instances, it may be desirable to declare a class as
 abstract (meaning that it cannot be instantiated, but non-abstract derived
-classes can). This can be done with the boolean `isAbstract` property. For
+classes can). There are several ways of marking a class as abstract listed
+below, in order of preference (with the most preferred being first).
+
+#### SHACL Validated Abstract Classes
+
+A class can be prevented from being directly instantiated using SHACL by adding
+a constraint on the shape that it cannot be of its own type. This can be done
+with the following turtle:
+
+```ttl
+
+<MyClass> a owl:Class, sh:NodeShape ;
+    # SHACL to prevent a class from being instansiated as this exact type
+    sh:property [
+        sh:path rdf:type ;
+        sh:not [ sh:hasValue <MyClass> ]
+    ] .
+
+```
+
+`shacl2code` will detect this pattern and generate abstract bindings for
+`MyClass`.
+
+This method is most preferred, since it is enforced by SHACL and not just
+`shacl2code` bindings
+
+#### shacl2code Annotation
+
+`shacl2code` has a custom annotation that can be used to mark a class as
+abstract. This can be done with the boolean `isAbstract` property. For
 example, the following turtle will declare a class as abstract:
 
 ```ttl
@@ -166,9 +195,10 @@ example, the following turtle will declare a class as abstract:
 The `isAbstract` property is _not_ inherited by derived classes, so any derived
 classes are automatically concrete unless they indicate otherwise.
 
-Note that for compatibility reasons, it is also possible to define a class as
-abstract by declaring it to be of type: `http://spdx.invalid./AbstractClass`,
-but this is not preferred.
+#### SPDX Abstract Class Parent
+
+It is also possible to define a class as abstract by declaring it to be of
+type: `http://spdx.invalid./AbstractClass`, but this is not preferred.
 
 [pytest]: https://www.pytest.org
 [pytest-cov]: https://pytest-cov.readthedocs.io/en/latest/

{shacl2code-0.0.14 → shacl2code-0.0.16}/src/shacl2code/lang/__init__.py

@@ -6,6 +6,7 @@
 from .lang import LANGUAGES  # noqa: F401
 
 # All renderers must be imported here to be registered
+from .cpp import CppRender  # noqa: F401
 from .jinja import JinjaRender  # noqa: F401
-from .python import PythonRender  # noqa: F401
 from .jsonschema import JsonSchemaRender  # noqa: F401
+from .python import PythonRender  # noqa: F401

{shacl2code-0.0.14 → shacl2code-0.0.16}/src/shacl2code/lang/common.py

@@ -7,9 +7,12 @@ import sys
 import os
 from pathlib import Path
 from contextlib import contextmanager
+import jinja2
 from jinja2 import Environment, FileSystemLoader, TemplateRuntimeError
+from markupsafe import Markup
 from rdflib.namespace import SH
 from ..model import SHACL2CODE
+from ..version import VERSION
 
 THIS_DIR = Path(__file__).parent
 
@@ -19,7 +22,7 @@ class OutputFile(object):
         self.path = path
 
     @contextmanager
-    def open(self):
+    def open(self, mode):
         if self.path == "-":
             yield sys.stdout
         else:
@@ -27,34 +30,15 @@ class OutputFile(object):
                 yield f
 
 
-class BasicJinjaRender(object):
-    """
-    Common Jinja Template Renderer
-
-    Renderers that only use a single Jinja file can derive from this class. For
-    example:
-
-        @language("my-lang")
-        class MyRendered(BasicJinjaRenderer):
-            HELP = "Generates my-lang bindings"
+@jinja2.pass_context
+def include_file(ctx, name):
+    env = ctx.environment
+    return Markup(env.loader.get_source(env, name)[0])
 
-            def __init__(self, args):
-                super().__init__(args, PATH / TO / TEMPLATE)
-    """
-
-    def __init__(self, args, template):
-        self.__output = args.output
-        self.__template = template
 
-    @classmethod
-    def get_arguments(cls, parser):
-        parser.add_argument(
-            "--output",
-            "-o",
-            type=OutputFile,
-            help="Output file or '-' for stdout",
-            required=True,
-        )
+class JinjaTemplateRender(object):
+    def __init__(self):
+        pass
 
     def get_additional_render_args(self):
         return {}
@@ -72,6 +56,7 @@ class BasicJinjaRender(object):
         env.globals["abort"] = abort_helper
         env.globals["SHACL2CODE"] = SHACL2CODE
         env.globals["SH"] = SH
+        env.globals["SHACL2CODE_VERSION"] = VERSION
         template = env.get_template(template.name)
 
         render = template.render(
@@ -141,13 +126,49 @@ class BasicJinjaRender(object):
         env = {
             "get_all_derived": get_all_derived,
             "get_all_named_individuals": get_all_named_individuals,
+            "include_file": include_file,
             **self.get_extra_env(),
         }
 
-        with self.__output.open() as f:
-            self.render(
-                self.__template,
-                f,
-                extra_env=env,
-                render_args=render_args,
-            )
+        for output, template, args in self.get_outputs():
+            with output.open("w") as f:
+                self.render(
+                    template,
+                    f,
+                    extra_env=env,
+                    render_args={**render_args, **args},
+                )
+
+
+class BasicJinjaRender(JinjaTemplateRender):
+    """
+    Common Jinja Template Renderer
+
+    Renderers that only use a single Jinja file can derive from this class. For
+    example:
+
+        @language("my-lang")
+        class MyRendered(BasicJinjaRenderer):
+            HELP = "Generates my-lang bindings"
+
+            def __init__(self, args):
+                super().__init__(args, PATH / TO / TEMPLATE)
+    """
+
+    def __init__(self, args, template):
+        super().__init__()
+        self.__output = args.output
+        self.__template = template
+
+    @classmethod
+    def get_arguments(cls, parser):
+        parser.add_argument(
+            "--output",
+            "-o",
+            type=OutputFile,
+            help="Output file or '-' for stdout",
+            required=True,
+        )
+
+    def get_outputs(self):
+        yield self.__output, self.__template, {}

shacl2code-0.0.16/src/shacl2code/lang/cpp.py

@@ -0,0 +1,224 @@
+#
+# Copyright (c) 2024 Joshua Watt
+#
+# SPDX-License-Identifier: MIT
+
+from .common import JinjaTemplateRender
+from .lang import language, TEMPLATE_DIR
+from ..version import VERSION
+
+import re
+import textwrap
+from pathlib import Path
+
+
+def varname(*name):
+    name = "_".join(name)
+    # Any invalid characters at the beginning of the name are removed (except
+    # "@")
+    name = re.sub(r"^[^a-zA-Z0-9_@]*", "", name)
+    # Any other invalid characters are replaced with "_" (including "@")
+    name = re.sub(r"[^a-zA-Z0-9_]", "_", name)
+    # Consolidate runs of "_" to a single one
+    name = re.sub(r"__+", "_", name)
+    return name
+
+
+def parent_cpp_classes(cls, classes):
+    if cls.parent_ids:
+        parents = [varname(*classes.get(i).clsname) for i in cls.parent_ids]
+    else:
+        parents = ["SHACLObject"]
+
+    if cls.is_extensible:
+        parents = [f"SHACLExtensibleObject<{p}>" for p in parents]
+
+    return parents
+
+
+def prop_is_list(prop):
+    return prop.max_count is None or prop.max_count != 1
+
+
+def id_str(s):
+    return re.sub(r"[^a-zA-Z0-9_]", "_", s)
+
+
+def comment_wrap(s):
+    return "\n".join(["*/", s, "/*"])
+
+
+@language("cpp")
+class CppRender(JinjaTemplateRender):
+    HELP = "C++ Language Bindings"
+
+    SOURCES = (
+        "datetime.cpp",
+        "decode.cpp",
+        "encode.cpp",
+        "errorhandler.cpp",
+        "extensible.cpp",
+        "link.cpp",
+        "namedindividual.cpp",
+        "object.cpp",
+        "objectpath.cpp",
+        "objectset.cpp",
+        "property.cpp",
+        "propertyvalue.cpp",
+        "refproperty.cpp",
+        "type.cpp",
+        "util.cpp",
+    )
+
+    HEADERS = (
+        "api.hpp",
+        "datetime.hpp",
+        "decode.hpp",
+        "encode.hpp",
+        "errorhandler.hpp",
+        "exceptions.hpp",
+        "extensible.hpp",
+        "link.hpp",
+        "namedindividual.hpp",
+        "object.hpp",
+        "objectpath.hpp",
+        "objectset.hpp",
+        "prop.hpp",
+        "property.hpp",
+        "propertyvalue.hpp",
+        "ref.hpp",
+        "refproperty.hpp",
+        "type.hpp",
+        "util.hpp",
+        "walk.hpp",
+    )
+
+    def __init__(self, args):
+        super().__init__()
+        self.basename = args.basename
+        self.namespace = args.namespace or id_str(args.basename.name)
+        self.lib_version = args.version
+        self.description = (
+            args.description or f"shacl2code generated binding {args.basename.name}"
+        )
+        self.macro_prefix = id_str("SHACL2CODE_" + self.basename.name).upper()
+
+    @classmethod
+    def get_arguments(cls, parser):
+        parser.add_argument(
+            "--output",
+            "-o",
+            type=Path,
+            help="Output file basename",
+            dest="basename",
+            required=True,
+        )
+
+        parser.add_argument(
+            "--namespace",
+            "-n",
+            help="Output namespace. If unspecified, defaults to output basename",
+        )
+
+        parser.add_argument(
+            "--version",
+            metavar="MAJOR[.MINOR[.MICRO]]",
+            default=VERSION,
+            help="Library version",
+        )
+
+        parser.add_argument(
+            "--description",
+            help="Library description",
+        )
+
+    def get_outputs(self):
+        def suffix(s):
+            return self.basename.parent / (self.basename.name + s)
+
+        t = TEMPLATE_DIR / "cpp"
+
+        for s in self.SOURCES:
+            yield self.basename.parent / s, t / (s + ".j2"), {}
+
+        for s in self.HEADERS:
+            guard = f"_{self.macro_prefix}_{id_str(s).upper()}"
+            yield self.basename.parent / s, t / (s + ".j2"), {
+                "guard_begin": comment_wrap(
+                    textwrap.dedent(
+                        f"""\
+                        #ifndef {guard}
+                        #define {guard}
+                        """
+                    )
+                ),
+                "guard_end": comment_wrap(f"#endif // {guard}"),
+            }
+
+        yield suffix(".cpp"), t / "source.j2", {}
+        yield suffix(".hpp"), t / "header.j2", {
+            "headers": self.HEADERS,
+        }
+        yield suffix("-jsonld.cpp"), t / "jsonld-source.j2", {}
+        yield suffix("-jsonld.hpp"), t / "jsonld-header.j2", {}
+
+        yield self.basename.parent / "Makefile", t / "Makefile.j2", {
+            "lib_obj_files": " ".join(
+                s.replace(".cpp", ".o")
+                for s in self.SOURCES
+                + (
+                    f"{self.basename.name}.cpp",
+                    f"{self.basename.name}-jsonld.cpp",
+                )
+            ),
+            "headers": self.HEADERS
+            + (
+                f"{self.basename.name}.hpp",
+                f"{self.basename.name}-jsonld.hpp",
+            ),
+        }
+
+        yield suffix("-validate.cpp"), t / "validate.j2", {}
+        yield suffix(".pc"), t / "pkgconfig.pc.j2", {}
+        yield self.basename.parent / "Doxyfile", t / "Doxyfile.j2", {}
+
+    def get_extra_env(self):
+        return {
+            "varname": varname,
+            "prop_is_list": prop_is_list,
+            "parent_cpp_classes": parent_cpp_classes,
+            "macro_prefix": self.macro_prefix,
+            "api_def_begin": comment_wrap(
+                textwrap.dedent(
+                    f"""\
+                    #ifndef DOXYGEN_SKIP
+                    #include "api.hpp"
+                    // These are so that we don't have to use Jinja templates below since that messes up the formatting
+                    #define EXPORT {self.macro_prefix}_API
+                    #define LOCAL  {self.macro_prefix}_LOCAL
+                    #endif // DOXYGEN_SKIP
+                    """
+                )
+            ),
+            "api_def_end": comment_wrap(
+                textwrap.dedent(
+                    """\
+                    #undef EXPORT
+                    #undef LOCAL
+                    """
+                )
+            ),
+            "ns_begin": comment_wrap(
+                "\n".join(f"namespace {n} {{" for n in self.namespace.split("::"))
+            ),
+            "ns_end": comment_wrap("\n".join("}" for n in self.namespace.split("::"))),
+        }
+
+    def get_additional_render_args(self):
+        return {
+            "basename": self.basename.name,
+            "namespace": self.namespace,
+            "nsprefix": f"::{self.namespace}" if self.namespace else "",
+            "lib_version": self.lib_version,
+            "lib_description": self.description,
+        }