jolt 0.9.419__py3-none-any.whl → 0.9.430__py3-none-any.whl

jolt/plugins/cmake.py

@@ -1,3 +1,4 @@
+from jolt import attributes
 from jolt import influence
 from jolt import Task
 from jolt import utils
@@ -6,31 +7,98 @@ from jolt.error import raise_task_error_if
 import os
 
 
+def options(attrib):
+    """
+    Decorates a CMake task with an alternative ``options`` attribute.
+
+    The new attribute will be concatenated with the regular
+    ``options`` attribute.
+
+    Args:
+        attrib (str): Name of alternative attribute.
+            Keywords are expanded.
+    """
+    return utils.concat_attributes("options", attrib)
+
+
+def requires(version=None):
+    """ Decorator to add CMake requirements to a task. """
+
+    import jolt.pkgs.cmake
+
+    def decorate(cls):
+        cls = attributes.requires("requires_cmake")(cls)
+        cls.requires_cmake = ["cmake" + (f":version={version}" if version else "")]
+        return cls
+
+    return decorate
+
+
+def use_ninja():
+    """
+    Decorator to add Ninja dependencies to CMake task.
+
+    It also selects Ninja as the CMake generator and builder.
+    """
+
+    import jolt.pkgs.ninja
+
+    def decorate(cls):
+        cls = attributes.requires("requires_ninja")(cls)
+        cls.generator = "Ninja"
+        cls.requires_ninja = ["ninja"]
+        return cls
+
+    return decorate
+
+
+@attributes.common_metadata()
+@options("options")
 class CMake(Task):
     """ Builds and publishes a CMake project """
-
     abstract = True
 
     cmakelists = "CMakeLists.txt"
     """ Path to CMakeLists.txt or directory containing CMakelists.txt """
 
+    config = "Release"
+    """ The default build configuration to use """
+
     generator = None
+    """ The build file generator that CMake should use """
 
     incremental = True
+    """ Keep build directories between Jolt invocations """
 
     options = []
     """ List of options and their values (``option[:type]=value``) """
 
+    srcdir = None
+    """ Source directory. If not specified, the task working directory is used. """
+
+    install = ["install"]
+    """ List of install build targets. If empty, the default install target is used. """
+
+    def clean(self, tools):
+        cmake = tools.cmake(incremental=self.incremental)
+        cmake.clean()
+
     def run(self, deps, tools):
+        self.deps = deps
         raise_task_error_if(not self.cmakelists, self, "cmakelists attribute has not been defined")
 
-        cmake = tools.cmake(incremental=self.incremental)
-        cmake.configure(tools.expand(self.cmakelists), *["-D" + tools.expand(option) for option in self.options], generator=self.generator)
-        cmake.build()
-        cmake.install()
+        config = tools.expand(str(self.config))
+        options = self._options()
+        options += ["CMAKE_BUILD_TYPE=" + config]
+
+        with tools.cwd(self.srcdir or self.joltdir):
+            cmake = tools.cmake(deps, incremental=self.incremental)
+            cmake.configure(tools.expand(self.cmakelists), *["-D" + tools.expand(option) for option in options], generator=self.generator)
+            for target in self.install or ["install"]:
+                cmake.install(config=config, target=target)
 
     def publish(self, artifact, tools):
-        cmake = tools.cmake()
+        cmake = tools.cmake(incremental=self.incremental)
         cmake.publish(artifact)
 
 

jolt/plugins/cxxinfo.py

@@ -1,4 +1,5 @@
 from jolt.cache import ArtifactListAttribute
+from jolt.cache import ArtifactStringAttribute
 from jolt.cache import ArtifactAttributeSet
 from jolt.cache import ArtifactAttributeSetProvider
 
@@ -7,6 +8,10 @@ class CppInfoListVariable(ArtifactListAttribute):
     pass
 
 
+class CppInfoStringVariable(ArtifactStringAttribute):
+    pass
+
+
 class CppInfoDictVariable(ArtifactListAttribute):
     def __init__(self, artifact, name):
         super(CppInfoDictVariable, self).__init__(artifact, name)
@@ -26,6 +31,8 @@ class CppInfo(ArtifactAttributeSet):
             return CppInfoListVariable(self._artifact, "asflags")
         if name == "cflags":
             return CppInfoListVariable(self._artifact, "cflags")
+        if name == "crt":
+            return CppInfoStringVariable(self._artifact, "crt")
         if name == "cxxflags":
             return CppInfoListVariable(self._artifact, "cxxflags")
         if name == "incpaths":

jolt/plugins/fetch.py

@@ -0,0 +1,141 @@
+import hashlib
+from jolt import BooleanParameter, Parameter
+from jolt.plugins.git import ErrorDict
+from jolt.tasks import Resource, TaskRegistry
+from jolt import filesystem as fs
+from jolt import utils
+from jolt.error import raise_error_if
+from jolt.loader import JoltLoader
+from jolt.tools import SUPPORTED_ARCHIVE_TYPES
+
+
+class Fetch(Resource):
+    """
+    Fetch a file from a URL and extract it.
+
+    By default, the fetched file is extracted if it is a supported archive type.
+    Extraction may be disable by assigning the `extract` parameter to false.
+
+    The fetched content is placed in a build directory named after the resource.
+    The `path` parameter can be used to specify a different location relative to
+    the workspace root.
+
+    The path of the fetched content is made available to consuming tasks through
+    the `fetch` attribute. The `fetch` attribute is a dictionary where the key
+    is the name of the fetched file and the value is a path relative to the
+    workspace root. You can specify an alias for the filename / key through the
+    `alias` parameter.
+
+    The plugin must be loaded before it can be used. This is done by importing
+    the module, or by adding the following line to the configuration file:
+
+    .. code-block:: ini
+
+            [fetch]
+
+
+    Example:
+
+    .. code-block:: python
+
+            from jolt.plugins import fetch
+
+            class Example(Task):
+                requires = ["fetch:alias=zlib,url=https://zlib.net/zlib-1.3.1.tar.gz"]
+
+                def run(self, deps, tools):
+                    self.info("The source tree is located at: {fetch[zlib]}")
+                    with tools.cwd(self.fetch["zlib"]):
+                        tools.run("make")
+
+            """
+
+    name = "fetch"
+    alias = Parameter(required=False, help="Name of the task used when referencing content. Defaults to the filename of the fetched file.")
+    extract = BooleanParameter(default=True, help="Whether to extract the fetched file.")
+    path = Parameter(required=False, help="Destination directory.")
+    url = Parameter(help="URL to fetch from.")
+    md5 = Parameter(required=False, help="Expected MD5 hash of the fetched file.")
+    sha256 = Parameter(required=False, help="Expected SHA256 hash of the fetched file.")
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.joltdir = JoltLoader.get().joltdir
+
+        # Set the path to the extraction directory
+        if self.path.is_unset():
+            self.abspath = self.tools.builddir(utils.canonical(self.short_qualified_name), incremental="always", unique=False)
+            if not self._extract():
+                # Join with filename if not extracting
+                self.abspath = fs.path.join(self.abspath, self._get_filename())
+        else:
+            self.abspath = fs.path.join(self.joltdir, str(self.path) or self._get_name())
+
+        self.relpath = fs.path.relpath(self.abspath, self.tools.wsroot)
+
+    def _extract(self):
+        """ Check if the fetched file should/can be extracted. """
+        filename = self._get_filename()
+
+        if not any([filename.endswith(ext) for ext in SUPPORTED_ARCHIVE_TYPES]):
+            return False
+
+        return bool(self.extract)
+
+    def _acquire_ws(self):
+        # Create the destination directory if it does not exist
+        self.tools.rmtree(self.abspath, ignore_errors=True)
+        self.tools.mkdir(fs.path.dirname(self.abspath), recursively=True)
+
+        if self._extract():
+            with self.tools.tmpdir() as tmpdir, self.tools.cwd(tmpdir):
+                filename = self._get_filename()
+                self.tools.download(self.url, filename)
+                self._verify_sha256(filename)
+                self.tools.extract(filename, self.abspath)
+        else:
+            self.tools.download(self.url, self.abspath)
+            self._verify_sha256(self.abspath)
+
+    def acquire(self, artifact, deps, tools, owner):
+        self._acquire_ws()
+        self._assign_fetch(owner)
+        artifact.worktree = fs.path.relpath(self.abspath, owner.joltdir)
+
+    def _assign_fetch(self, task, none=False):
+        if not hasattr(task, "fetch"):
+            task.fetch = ErrorDict(self)
+        if none:
+            # None means the git repo is not cloned or checked out
+            # and should not be included in the git dictionary
+            # of the consuming task yet. If the consuming task
+            # requires the git repo for its influence collection,
+            # the dict will raise an error. The solution is to
+            # assign hash=true to the git requirement which
+            # will cause the git repo to be cloned and checked out
+            # before the influence collection is performed.
+            task.fetch[self._get_name()] = None
+        else:
+            # Assign the git repo to the consuming task.
+            # The git repo is cloned and checked out before
+            # any influence collection is performed.
+            task.fetch[self._get_name()] = fs.path.relpath(self.abspath, task.joltdir)
+
+    def _get_name(self):
+        return str(self.alias) if self.alias.is_set() else self._get_filename()
+
+    def _get_filename(self):
+        return fs.path.basename(str(self.url))
+
+    def _verify_sha256(self, filepath):
+        if not self.sha256.is_set():
+            return
+        actual_hash = self.tools.checksum_file(filepath, hashfn=hashlib.sha256)
+        expected_hash = str(self.sha256)
+        raise_error_if(
+            actual_hash != expected_hash,
+            f"SHA256 hash mismatch for fetched file '{filepath}': expected {expected_hash}, got {actual_hash}"
+        )
+
+
+TaskRegistry.get().add_task_class(Fetch)

jolt/plugins/git.py

@@ -4,7 +4,7 @@ import re
 from threading import RLock
 import urllib.parse
 
-from jolt.tasks import BooleanParameter, Export, Parameter, TaskRegistry, WorkspaceResource
+from jolt.tasks import BooleanParameter, Export, IntParameter, Parameter, TaskRegistry, WorkspaceResource
 from jolt.influence import FileInfluence, HashInfluenceRegistry
 from jolt.tools import Tools
 from jolt.loader import JoltLoader, workspace_locked
@@ -37,7 +37,7 @@ class GitRepository(object):
         self.url = url
         self.default_refspecs = [
             '+refs/heads/*:refs/remotes/origin/*',
-            '+refs/tags/*:refs/remotes/origin/*',
+            '+refs/tags/*:refs/tags/*',
         ]
         self.refspecs = refspecs or []
         self._tree_hash = {}
@@ -76,7 +76,7 @@ class GitRepository(object):
     def is_indexed(self):
         return self.is_cloned() and fs.path.exists(self._git_index())
 
-    def clone(self):
+    def clone(self, submodules=False):
         log.info("Cloning into {0}", self.path)
 
         # Get reference repository path
@@ -111,14 +111,14 @@ class GitRepository(object):
 
                 utils.call_and_catch(self.tools.run, "git remote remove origin", output=False)
                 self.tools.run("git remote add origin {}", self.url, output_on_error=True)
-                self._fetch_origin()
+                self._fetch_origin(submodules=submodules)
                 self.tools.run("git checkout -f FETCH_HEAD", output_on_error=True)
         else:
             # Get configurable extra clone options
             extra_clone_options = config.get("git", "clone_options", "")
 
             if refpath and os.path.isdir(refpath):
-                self.tools.run("git clone --reference-if-able {0} {1} {2} {3}", refpath, extra_clone_options, self.url, self.path, output_on_error=True)
+                self.tools.run("git clone --reference-if-able  {0} {1} {2} {3}", refpath, extra_clone_options, self.url, self.path, output_on_error=True)
             else:
                 self.tools.run("git clone {0} {1} {2}", extra_clone_options, self.url, self.path, output_on_error=True)
 
@@ -128,12 +128,12 @@ class GitRepository(object):
             "Failed to clone repository '{0}'", self.relpath)
 
     @utils.retried.on_exception(JoltCommandError, pattern="Command failed: git fetch", count=6, backoff=[2, 5, 10, 15, 20, 30])
-    def _fetch_origin(self):
+    def _fetch_origin(self, submodules=False):
         # Get configurable extra clone options
         extra_fetch_options = config.get("git", "fetch_options", "")
 
         with self.tools.cwd(self.path):
-            self.tools.run("git fetch {0} origin", extra_fetch_options, output_on_error=True)
+            self.tools.run("git fetch {0} {1} origin", "", extra_fetch_options, output_on_error=True)
 
     @utils.cached.instance
     def diff_unchecked(self):
@@ -276,7 +276,7 @@ class GitRepository(object):
                 what=commit or refspec or '',
                 output_on_error=True)
 
-    def checkout(self, rev, commit=None):
+    def checkout(self, rev, commit=None, submodules=False):
         if rev == self._last_rev:
             log.debug("Checkout skipped, already @ {}", rev)
             return False
@@ -284,16 +284,24 @@ class GitRepository(object):
         with self.tools.cwd(self.path):
             try:
                 self.tools.run("git checkout -f {rev}", rev=rev, output=False)
+                if submodules:
+                    self._update_submodules()
             except Exception:
                 self.fetch(commit=commit)
                 try:
                     self.tools.run("git checkout -f {rev}", rev=rev, output_on_error=True)
+                    if submodules:
+                        self._update_submodules()
                 except Exception:
                     raise_error("Commit does not exist in remote for '{}': {}", self.relpath, rev)
         self._original_head = False
         self._last_rev = rev
         return True
 
+    def _update_submodules(self):
+        with self.tools.cwd(self.path):
+            self.tools.run("git submodule update --init --recursive", output_on_error=True)
+
 
 _gits = {}
 
@@ -444,6 +452,12 @@ class Git(WorkspaceResource, FileInfluence):
     path = Parameter(required=False, help="Local path where the repository should be cloned.")
     """ Alternative path where the repository should be cloned. Relative to ``joltdir``. Optional. """
 
+    submodules = BooleanParameter(default=False, help="Initialize and update git submodules after cloning.")
+    """ Initialize and update git submodules after cloning. Default ``False``. Optional. """
+
+    clean = BooleanParameter(default=False, help="Clean repository after it has been used")
+    """ Removes untracked files from the repository. """
+
     _revision = Export(value=lambda t: t._export_revision())
     """ To worker exported value of the revision to be checked out. """
 
@@ -463,6 +477,9 @@ class Git(WorkspaceResource, FileInfluence):
             self.abspath = fs.path.join(self.joltdir, str(self.path) or self._get_name())
             self.relpath = fs.path.relpath(self.abspath, self.tools.wsroot)
 
+        self.abspath = fs.path.normpath(self.abspath)
+        self.relpath = fs.path.normpath(self.relpath)
+
         # Create the git repository
         self.refspecs = kwargs.get("refspecs", [])
         self.git = new_git(self.url, self.abspath, self.relpath, self.refspecs)
@@ -507,6 +524,11 @@ class Git(WorkspaceResource, FileInfluence):
         self._assign_git(owner)
         artifact.worktree = fs.path.relpath(self.abspath, owner.joltdir)
 
+    def release(self, artifact, deps, tools, owner):
+        if self.clean:
+            self.git.clean()
+            self.git.reset()
+
     def prepare_ws_for(self, task):
         """ Prepare the workspace for the task.
 
@@ -531,7 +553,7 @@ class Git(WorkspaceResource, FileInfluence):
     def _acquire_ws(self):
         commit = None
         if not self.git.is_cloned():
-            self.git.clone()
+            self.git.clone(submodules=bool(self.submodules))
         if not self._revision.is_imported:
             self.git.diff_unchecked()
         else:
@@ -544,7 +566,7 @@ class Git(WorkspaceResource, FileInfluence):
             # Should be safe to do this now
             rev = self.git.rev_parse(rev)
             if not self.git.is_head(rev) or self._revision.is_imported:
-                if self.git.checkout(rev, commit=commit):
+                if self.git.checkout(rev, commit=commit, submodules=bool(self.submodules)):
                     self.git.clean()
                     self.git.patch(self._diff.value)
 
@@ -575,7 +597,7 @@ class Git(WorkspaceResource, FileInfluence):
     @utils.cached.instance
     def get_influence(self, task):
         if not self.git.is_cloned():
-            self.git.clone()
+            self.git.clone(submodules=bool(self.submodules))
         if not self._revision.is_imported:
             self.git.diff_unchecked()
         rev = self._get_revision()

jolt/plugins/libtool.py

@@ -0,0 +1,63 @@
+from jolt import attributes
+
+
+class Libtool(object):
+    def __init__(self, tools):
+        self.tools = tools
+
+    def relocate(self, artifact, dirs=["lib"], prefix=None):
+        prefix = str(artifact.strings.install_prefix) if prefix is None else prefix
+        for dir in dirs:
+            with self.tools.cwd(artifact.path, dir):
+                for file in self.tools.glob("*.la"):
+                    self.tools.replace_in_file(file, prefix, artifact.final_path)
+
+
+def relocate(dirs=["lib"]):
+    """
+    Relocate libtool archive files (.la) published by task.
+
+    When an artifact is published, all .la files found in the specified
+    directories will have their install prefix updated to the artifact's final path.
+    The original install prefix is stored in the artifact's strings metadata
+    under the key 'libtool_prefix' for use during unpacking.
+
+      :param dirs: List of directories inside the artifact to relocate .la files in.
+
+    """
+
+    def decorate(cls):
+        original_publish = cls.publish
+        original_unpack = cls.unpack
+
+        def publish(self, artifact, tools):
+            original_publish(self, artifact, tools)
+            lt = Libtool(tools)
+            lt.relocate(artifact, dirs, prefix=artifact.strings.install_prefix)
+            artifact.libtool_prefix = artifact.final_path
+
+        def unpack(self, artifact, tools):
+            original_unpack(self, artifact, tools)
+            lt = Libtool(tools)
+            lt.relocate(artifact, dirs, prefix=artifact.strings.libtool_prefix)
+            artifact.strings.libtool_prefix = None
+
+        cls.publish = publish
+        cls.unpack = unpack
+
+        return cls
+
+    return decorate
+
+
+def requires():
+    """ Decorator to add Libtool requirement to a task. """
+
+    import jolt.pkgs.libtool
+
+    def decorate(cls):
+        cls = attributes.requires("requires_libtool")(cls)
+        cls.requires_libtool = ["libtool"]
+        return cls
+
+    return decorate

jolt/plugins/meson.py

@@ -0,0 +1,61 @@
+from jolt import Task, attributes
+
+
+@attributes.common_metadata()
+class Meson(Task):
+    """ Base class for Meson-based build tasks. """
+
+    abstract = True
+    """ This is an abstract base class that should be inherited by concrete tasks. """
+
+    incremental = True
+    """
+    Whether to use incremental builds.
+    If True, the build directories are preserved between runs.
+    """
+
+    options = []
+    """
+    Additional options to pass to the `meson` command.
+    """
+
+    srcdir = None
+    """
+    Source directory for the Meson project.
+
+    If None, defaults to the task work directory (joltdir).
+    """
+
+    def clean(self, tools):
+        at = tools.meson(incremental=self.incremental)
+        at.clean()
+
+    def run(self, deps, tools):
+        self.deps = deps
+        options = tools.expand(self.options)
+        at = tools.meson(deps, incremental=self.incremental)
+        at.configure(self.srcdir or self.joltdir, *options)
+        at.build()
+        at.install()
+
+    def publish(self, artifact, tools):
+        at = tools.meson(incremental=self.incremental)
+        at.publish(artifact)
+
+
+def requires(meson=True, ninja=True):
+    """ Decorator to add Meson and Ninja requirements to a task. """
+
+    import jolt.pkgs.meson
+    import jolt.pkgs.ninja
+
+    def decorate(cls):
+        if meson:
+            cls = attributes.requires("requires_meson")(cls)
+            cls.requires_meson = ["meson"]
+        if ninja:
+            cls = attributes.requires("requires_ninja")(cls)
+            cls.requires_ninja = ["ninja"]
+        return cls
+
+    return decorate