Merge pull request #19 from Garcia6l20/feature/cmake

Feature/cmake

Author: Garcia6l20

.github/workflows/main.yaml

@@ -46,8 +46,7 @@ jobs:
           with_conan: false
           targets: |
             libraries.use-simple-lib \
-            dan.io.test-mbedtls      \
-            dan.io.UseCatch2
+            dan-examples.cxx.dan.io.test-spdlog
 
     name: ${{ matrix.config.name }}
     runs-on: ${{ matrix.config.os }}
@@ -68,6 +67,7 @@ jobs:
           #       while fmt (built within examples) does not compile with defaul msys-gcc :)
           install: >-
             mingw-w64-x86_64-gcc
+            mingw-w64-x86_64-make
 
       - name: Set up Python 3.11
         uses: actions/setup-python@v3
@@ -98,6 +98,7 @@ jobs:
       - name: Configure
         run: |
           cd examples
+          dan-io configure -s github.api_token=${{ secrets.GITHUB_TOKEN }}
           dan configure -v                \
             -t default                    \
             -s install.destination=dist   \

dan/__init__.py

@@ -1,4 +1,5 @@
 import sys
+import dan.logging
 import dan.core.include
 from dan.core.include import include, requires
 from dan.core.generator import generator

dan/cli/click.py

@@ -1,12 +1,12 @@
 import dataclasses
 from enum import Enum
 import types as typs
-import typing as t
 from click import *
 
 import inspect
 import asyncio
 
+import dan.core.typing as t
 from dan import logging
 
 class AsyncContext(Context):
@@ -49,6 +49,8 @@ def gen_comps(fields, parts: list[str], prefix=''):
                     type = field.type
                     if isinstance(type, typs.GenericAlias):
                         type = t.get_origin(type)
+                    elif t.is_optional(type):
+                        type = t.get_args(type)[0]
                     if dataclasses.is_dataclass(type):
                         subfields = dataclasses.fields(type)
                         subparts = parts[1:]

dan/cli/io.py

@@ -6,15 +6,21 @@
 
 from dan.cli import click
 from dan.core.requirements import parse_package
+from dan.core.cache import Cache
+from dan.io.repositories import RepositoriesSettings, _get_settings
 from dan.make import Make
 
+def get_source_path():
+    from dan.cxx.detect import get_dan_path
+    source_path = get_dan_path() / 'deps'
+    source_path.mkdir(exist_ok=True, parents=True)
+    return source_path
+
 _make : Make = None
 async def get_make(toolchain='default', quiet=True):
     global _make
     if _make is None:
-        from dan.cxx.detect import get_dan_path
-        source_path = get_dan_path() / 'deps'
-        source_path.mkdir(exist_ok=True, parents=True)
+        source_path = get_source_path()
         os.chdir(source_path)
         (source_path / 'dan-build.py').touch()
         make = Make(source_path / 'build', quiet=quiet)
@@ -58,6 +64,14 @@ async def make_context(toolchain='default', quiet=True):
 def cli():
     pass
 
+@cli.command()
+@click.option('--setting', '-s', 'settings', type=click.SettingsParamType(RepositoriesSettings), multiple=True)
+async def configure(settings):
+    io_settings = _get_settings()
+    from dan.core.settings import apply_settings
+    apply_settings(io_settings, *settings, logger=click.logger)
+    await Cache.save_all()
+
 @cli.group()
 def ls():
     """Inspect stuff"""
@@ -115,6 +129,19 @@ async def versions(library: str):
             else:
                 click.echo(f' - {v}')
 
+@ls.command()
+@click.argument('LIBRARY')
+async def options(library: str):
+    """Get LIBRARY's available options"""
+    async with make_context():
+        lib = await get_library(library)
+        await lib.initialize()
+        for o in lib.options:
+            current = ''
+            if o.value != o.default:
+                current = f', current: {o.value}'
+            click.echo(f'{o.name}: {o.help} (type: {o.type.__name__}, default: {o.default}{current})')
+
 @cli.command()
 @click.argument('NAME')
 async def search(name):

dan/cli/main.py

@@ -96,7 +96,7 @@ def cli(ctx: click.AsyncContext, **kwds):
 @click.option('--verbose', '-v', is_flag=True,
               help='Pring debug informations')
 @click.option('--toolchain', '-t', help='The toolchain to use',
-              type=click.ToolchainParamType())
+              type=click.ToolchainParamType(), envvar='DAN_TOOLCHAIN')
 @click.option('--setting', '-s', 'settings', help='Set or change a setting', multiple=True, type=click.SettingsParamType(Settings))
 @click.option('--option', '-o', 'options', help='Set or change an option', multiple=True, type=click.OptionsParamType())
 @click.option('--build-path', '-B', help='Path where dan has been initialized.',
@@ -108,7 +108,9 @@ async def configure(ctx: CommandsContext, toolchain: str, settings: tuple[str],
     """Configure dan project"""
     ctx(**kwds)  # update kwds
     if toolchain is None and ctx.make.config.toolchain is None:
-        toolchain = click.prompt('Toolchain', type=click.ToolchainParamType(), default='default')
+        from dan.cxx.detect import get_toolchains
+        tp = click.Choice(get_toolchains(create=False)["toolchains"].keys())
+        toolchain = click.prompt('Toolchain', type=tp, default='default')
 
     await ctx.make.configure(source_path, toolchain)
 
@@ -136,9 +138,15 @@ async def build(ctx: CommandsContext, force=False, **kwds):
     if force:
         await ctx.make.clean()
     await ctx.make.build()
-    # from dan.cxx import target_toolchain
-    # target_toolchain.compile_commands.update()
 
+@cli.command()
+@common_opts
+@click.argument('TARGETS', nargs=-1, type=click.TargetParamType())
+@pass_context
+async def install_dependencies(ctx: CommandsContext, **kwds):
+    """Build targets"""
+    ctx(**kwds)  # update kwds
+    await ctx.make.install_dependencies()
 
 @cli.command()
 @common_opts

dan/cmake/__init__.py

@@ -1 +1,2 @@
+from dan.cmake.project import Project
 from dan.cmake.configure_file import ConfigureFile

dan/cmake/project.py

@@ -0,0 +1,91 @@
+from dan.core.requirements import RequiredPackage
+from dan.core.target import Target, FileDependency, Installer
+from dan.core.runners import async_run
+from dan.core.pm import re_match
+from dan.core import aiofiles
+from dan.core.find import find_executable, find_file
+from dan.cxx import Toolchain
+
+import typing as t
+
+
+class Project(Target, internal=True):
+
+    cmake_targets: list[str] = None
+    cmake_config_definitions: dict[str, str] = dict()
+    cmake_patch_debug_postfix: list = None
+    cmake_options: dict[str, tuple[str, t.Any, str]] = None
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.cmake_cache_dep = FileDependency(self.build_path / 'CMakeCache.txt')
+        self.dependencies.add(self.cmake_cache_dep)
+        self.toolchain : Toolchain = self.context.get('cxx_target_toolchain')
+
+    async def _cmake(self, *cmake_args, **kwargs):
+        return await async_run(['cmake', *cmake_args], logger=self, cwd=self.build_path, **kwargs, env=self.toolchain.env)
+
+    @property
+    def _target_args(self):
+        targets_args = []
+        if self.cmake_targets is not None:
+            for target in self.cmake_targets:
+                targets_args.extend(('-t', target))
+        return targets_args
+
+    async def __initialize__(self):
+        if self.cmake_options is not None:
+            for name, (cmake_name, default, help) in self.cmake_options.items():
+                opt = self.options.add(name, default, help)
+                setattr(opt, 'cmake_name', cmake_name)
+        return await super().__initialize__()
+
+    async def __build__(self):
+        cmake_options = dict()
+        for opt in self.options:
+            if hasattr(opt, 'cmake_name'):
+                value = opt.value
+                if isinstance(value, bool):
+                    value = 'ON' if value else 'OFF'
+                cmake_options[opt.cmake_name] = value
+
+        cmake_options['CMAKE_PREFIX_PATH'] = self.makefile.root.pkgs_path.as_posix()
+
+        base_opts = []
+        if self.toolchain.system.startswith('msys'):
+            make = find_executable(r'.+make', self.toolchain.env['PATH'].split(';'), default_paths=False)
+            base_opts.extend((f'-GMinGW Makefiles', f'-DCMAKE_MAKE_PROGRAM={make.as_posix()}'))
+
+        await self._cmake(
+            self.source_path,
+            *base_opts,
+            f'-DCMAKE_BUILD_TYPE={self.toolchain.build_type.name.upper()}',
+            f'-DCMAKE_CONFIGURATION_TYPES={self.toolchain.build_type.name.upper()}',
+            f'-DCMAKE_C_COMPILER={self.toolchain.cc.as_posix()}',
+            f'-DCMAKE_CXX_COMPILER={self.toolchain.cxx.as_posix()}',
+            *[f'-D{k}={v}' for k, v in self.cmake_config_definitions.items()],
+            *[f'-D{k}={v}' for k, v in cmake_options.items()]
+        )
+        await self._cmake('--build', '.', '--parallel', *self._target_args)
+    
+    async def __install__(self, installer: Installer):
+        await self.build()
+        await self._cmake('.', f'-DCMAKE_INSTALL_PREFIX={installer.settings.destination}')
+        await self._cmake('--install', '.', *self._target_args)
+        await super().__install__(installer)
+        async with aiofiles.open(self.build_path / 'install_manifest.txt') as manifest_file:
+            manifest = await manifest_file.readlines()
+            
+        if self.cmake_patch_debug_postfix is not None and self.toolchain.build_type.is_debug_mode:
+            # fix: no 'd' postfix in MSVC pkgconfig
+            seach_paths = [
+                installer.settings.data_destination / 'pkgconfig',
+                installer.settings.libraries_destination / 'pkgconfig',
+            ]
+            for provided in self.provides:
+                pc_file = find_file(rf'{provided}\.pc', paths=seach_paths)
+                self.debug('patching %s', pc_file)
+                for name in self.cmake_patch_debug_postfix:
+                    await aiofiles.sub(pc_file, rf'-l{name}(\s)', rf'-l{name}d\g<1>')
+
+        installer.installed_files.extend(manifest)

dan/core/aiofiles.py

@@ -4,6 +4,11 @@
 
 import os as sync_os
 import stat
+import re
+import sys
+import errno
+import contextlib
+import time
 
 from dan.core.pathlib import Path
 
@@ -49,3 +54,75 @@ async def copy(src : Path, dest : Path, chunk_size=2048):
                 break
             await d.write(chunk)
     dest.chmod(src.stat().st_mode)
+
+
+async def sub(filepath, pattern, repl, **kwargs):
+    async with open(filepath) as f:
+        content = await f.read()
+    content = re.sub(pattern, repl, content, **kwargs)
+    async with open(filepath, 'w') as f:
+        await f.write(content)
+
+
+
+class FileLock:
+    def __init__(self, path: str|Path, timeout=None, poll_interval=0.1) -> None:
+        self._path = Path(path)
+        self._mode: int = 0o644
+        self._fh = None
+        self._timeout = timeout
+        self._poll_interval = poll_interval
+
+    def __del__(self):
+        if self.has_lock:
+            self.release()
+
+    @property
+    def locked(self):
+        return self._path.exists()
+
+    @property
+    def has_lock(self):
+        return self._fh is not None
+
+    def try_acquire(self):
+        flags = (
+            sync_os.O_WRONLY  # open for writing only
+            | sync_os.O_CREAT
+            | sync_os.O_EXCL  # together with above raise EEXIST if the file specified by filename exists
+            | sync_os.O_TRUNC  # truncate the file to zero byte
+        )
+        try:
+            self._fh = sync_os.open(self._path, flags, self._mode)
+            return True
+        except OSError as exception:  # re-raise unless expected exception
+            if not (
+                exception.errno == errno.EEXIST  # lock already exist
+                or (exception.errno == errno.EACCES and sys.platform == "win32")  # has no access to this lock
+            ):  # pragma: win32 no cover
+                raise
+            return False
+
+    async def acquire(self, timeout=None):
+        if timeout is None:
+            timeout = self._timeout
+        t0 = t1 = time.perf_counter()
+        while timeout is None or timeout < t1 - t0:
+            if self.try_acquire():
+                return True
+            await asyncio.sleep(self._poll_interval)
+            t1 = time.perf_counter()
+        return False
+
+    def release(self):
+        assert self._fh is not None
+        sync_os.close(self._fh)
+        self._fh = None
+        with contextlib.suppress(OSError):  # the file is already deleted and that's what we want
+            self._path.unlink()
+
+    async def __aenter__(self):
+        await self.acquire()
+    
+    async def __aexit__(self, *exc):
+        self.release()

dan/core/cache.py

@@ -128,4 +128,35 @@ def wrapper(self, *args, **kwds):
 
     return wrapper
 
-
+class _CachedProperty:
+    def __init__(self, getter: t.Callable[[], t.Any], cache_name=None):
+        self.__getter = getter
+        self.__name = getter.__name__
+        self.__cache_name = 'cache' if cache_name is None else cache_name
+
+    def __get__(self, instance, owner: type | None = None):
+        cache = getattr(instance, self.__cache_name)
+        if isinstance(cache, Cache):
+            cache = cache.data
+        value = cache.get(self.__name)
+        if value is None:
+            value = self.__getter(instance)
+            if value is not None:
+                cache[self.__name] = value
+        return value
+
+    def __set__(self, instance, value):
+        cache = getattr(instance, self.__cache_name)
+        if isinstance(cache, Cache):
+            cache = cache.data
+        cache[self.__name] = value
+
+    def __delete__(self, instance):
+        cache = getattr(instance, self.__cache_name)
+        del cache[self.__name]
+
+
+def cached_property(cache_name=None):
+    def wrapper(fn):
+        return _CachedProperty(fn, cache_name=cache_name)
+    return wrapper