fix several bugs and support meson 0.55.1

.gitignore

@@ -3,3 +3,4 @@ cmake-client.log
 dist
 *.egg-info
 __pycache__
+.idea

mcw/cmake.py

@@ -1,3 +1,4 @@
+from _datetime import datetime
 import os
 import sys
 import pickle
@@ -6,22 +7,31 @@
 import json
 import xml.etree.ElementTree as ETree
 
-from .logging import ServerLogHandler
+from .logging import ServerLogHandler, logger_fmt, logger_fmt_with_func
 from .util import find_executables
 from .commandtool import CommandToolWrapper
 from .server import (UnixSocketServer, NamedPipeServer)
 from .meson import Meson
+from typing import NamedTuple, List, Iterable, Union
 
 
+class cmake_target_t(NamedTuple):
+    name: str
+    id: str
+    type: str
+    filename: Union[None, str]
+
 class CMakeWrapper:
     """
     Class that emulates CMake commands and translates them to the equivalent in Meson.
     """
+    debug: int
+    logger: logging.Logger
 
     def __init__(self):
         self.version = [3, 10, 0]
         self.path = sys.argv[0]
-        self.debug = False
+        self.debug = 1
         self.command = 'generate'
         self.generator = None
         self.build_type = None
@@ -37,13 +47,22 @@ def __init__(self):
         else:
             self.server = UnixSocketServer(self)
         self.tool = CommandToolWrapper(self)
-        self.logger = None
+        self._datetime_str = datetime.now().strftime('%Y%m%d-%H%M%S.%f')
+        if 'MCW_LOG_LEVEL' in os.environ:
+            self.debug = int(os.environ['MCW_LOG_LEVEL'])
+        else:
+            self.debug = 1
+        if 'MCW_LOG_TO_DIFFERENT_FILES' in os.environ:
+            self._log_to_different_files = bool(os.environ['MCW_LOG_TO_DIFFERENT_FILES'])
+        else:
+            self._log_to_different_files = False
+        self.init_logging()
 
     def run(self, args):
         self.init_logging()
 
-        self.log('(args) "%s"' % args)
-        self.log('(cwd) "%s"' % os.getcwd())
+        self.logger.info('(args) "%s"' % args)
+        self.logger.info('(cwd) "%s"' % os.getcwd())
 
         # debug_connect()
 
@@ -59,10 +78,10 @@ def run(self, args):
             getattr(self, self.command + '_cmd')()
         except RuntimeError as e:
             print(e.args[0])
-            self.log(e)
+            self.logger.error(e.args[0], exc_info=e)
             exit(1)
         except Exception as e:
-            self.log(e)
+            self.logger.error('Uncaught error.', exc_info=e)
             raise e
         self.save_cache_entries()
 
@@ -204,50 +223,59 @@ def init_logging(self, dir=None):
         loggers = []
         self.logger = logging.getLogger('CMake Wrapper')
         loggers.append(self.logger)
-        self.meson.logger = logging.getLogger('Meson')
-        loggers.append(self.meson.logger)
-        self.server.logger = logging.getLogger('Server')
-        loggers.append(self.server.logger)
+        loggers.append(self.meson.get_logger())
+        loggers.append(self.server.get_logger())
 
         # Cleanup if reinitialized
         for logger in loggers:
             logger.handlers = []
 
-        if not dir and self.debug:
+        if not dir and self.debug > 0:
             dir = os.getcwd()
 
         # Setup handlers and formatters
         handlers = []
+        file_handler = None
         if dir:
-            handler = logging.FileHandler(os.path.join(dir, 'meson-cmake-wrapper.log'))
-            handler.setLevel(logging.INFO)
-            formatter = logging.Formatter('%(asctime)s - %(name)s: %(message)s')
-            handler.setFormatter(formatter)
-            handlers.append(handler)
-
-        if self.debug:
-            handler = logging.StreamHandler(sys.stderr)
-            handler.setLevel(logging.INFO)
-            formatter = logging.Formatter('%(name)s: %(message)s')
-            handler.setFormatter(formatter)
-            handlers.append(handler)
-
-            handler = ServerLogHandler(self.server)
-            handler.setLevel(logging.INFO)
-            formatter = logging.Formatter('%(name)s: %(message)s')
-            handler.setFormatter(formatter)
-            handlers.append(handler)
-
-        for logger in loggers:
-            logger.setLevel(logging.INFO)
+            if self._log_to_different_files:
+                log_file_name = 'meson-cmake-wrapper-{}.log'.format(self._datetime_str)
+            else:
+                log_file_name = 'meson-cmake-wrapper.log'
+            log_path = os.path.join(dir, log_file_name)
+
+            file_handler = logging.FileHandler(log_path)
+            file_handler.setLevel(logging.INFO)
+            file_handler.setFormatter(logger_fmt_with_func)
+            handlers.append(file_handler)
+        stderr_handler = logging.StreamHandler(sys.stderr)
+        stderr_handler.setLevel(logging.WARN)
+        stderr_handler.setFormatter(logger_fmt)
+        handlers.append(stderr_handler)
+        server_handler = ServerLogHandler(self.server)
+        server_handler.setLevel(logging.WARN)
+        server_handler.setFormatter(logger_fmt)
+        handlers.append(server_handler)
+        logger_level = logging.INFO
+        if self.debug == 0:
             for handler in handlers:
-                logger.addHandler(handler)
-
-    def log(self, msg):
-        if isinstance(msg, Exception):
-            self.logger.info(msg, exc_info=msg)
-        else:
-            self.logger.info(msg)
+                handler.setLevel(logging.WARN)
+            logger_level = logging.WARN
+        if self.debug >= 2:
+            server_handler.setLevel(logging.INFO)
+            logger_level = logging.INFO
+        if self.debug >= 3:
+            if file_handler:
+                file_handler.setLevel(logging.DEBUG)
+            logger_level = logging.DEBUG
+
+        for file_handler in handlers:
+            if self.debug > 1:
+                file_handler.setFormatter(logger_fmt_with_func)
+        for logger in loggers:
+            if logger_level:
+                logger.setLevel(logger_level)
+            for file_handler in handlers:
+                logger.addHandler(file_handler)
 
     def set_generator(self, generator):
         if generator == 'Ninja':
@@ -264,7 +292,7 @@ def set_generator(self, generator):
             raise Exception('Generator not supported: ' + generator)
         self.generator = generator
 
-        self.log('(generator) "%s"' % self.generator)
+        self.logger.info('(generator) "%s"' % self.generator)
 
     def set_source_dir(self, source_dir):
         if not os.path.exists(source_dir):
@@ -275,7 +303,7 @@ def set_source_dir(self, source_dir):
         self.source_dir = os.path.abspath(source_dir)
         self.meson.source_dir = self.source_dir
 
-        self.log('(source_dir) "%s"' % self.source_dir)
+        self.logger.info('(source_dir) "%s"' % self.source_dir)
 
     def set_build_dir(self, build_dir):
         if not os.path.exists(build_dir):
@@ -296,7 +324,7 @@ def set_build_dir(self, build_dir):
                 with open(meson_file, 'w') as file:
                     file.write('project(\'empty\')')
 
-        self.log('(build_dir) "%s"' % self.build_dir)
+        self.logger.info('(build_dir) "%s"' % self.build_dir)
 
     def set_build_type(self, build_type):
         self.build_type = build_type
@@ -313,7 +341,7 @@ def set_build_type(self, build_type):
 
         self.cache_entries['CMAKE_BUILD_TYPE'] = (build_type, 'STRING')
 
-        self.log('(build_type) "%s"' % self.build_type)
+        self.logger.info('(build_type) "%s"' % self.build_type)
 
     def get_entry(self, entry):
         if entry in self.cache_entries:
@@ -416,6 +444,7 @@ def gen_cmake_cache(self):
                 file.write('%s:%s=%s\n' % (entry[0], entry[1][1], entry[1][0]))
 
     def gen_cmake_project(self):
+        self.logger.warning('call gen_cmake_project()')
         with open(os.path.join(self.source_dir, 'CMakeLists.txt'), 'w') as file:
             file.write('cmake_minimum_required(VERSION %s)\n' % '.'.join(map(str, self.version)))
             file.write('project(%s)\n\n' % self.meson.get_project_name())
@@ -458,7 +487,7 @@ def gen_codeblocks_project(self):
             'name': 'all',
             'id': 'all',
             'type': 'custom',
-            'filename': ''
+            'filename': ['']
         }
 
         for target in [all_target] + self.meson.get_targets():
@@ -473,13 +502,14 @@ def gen_codeblocks_project(self):
                 'static library': '2',
                 'shared library': '3',
                 'custom': '4',
-                'run': '4'
+                'run': '4',
+                'shared module': '3' # Code::Blocks does not have shared module type as cmake and meson
             }[target['type']]
             ETree.SubElement(build_target, 'Option', {'type': ty})
 
             compiler = self.meson.get_compiler(target)
             if compiler:
-                ETree.SubElement(build_target, 'Option', {'compiler': 'gcc'})
+                ETree.SubElement(build_target, 'Option', {'compiler': compiler})
 
             compiler = ETree.SubElement(build_target, 'Compiler')
             for define in self.meson.get_defines(target):

mcw/logging.py

@@ -1,5 +1,15 @@
 import logging
 
+logger_fmt_with_func = logging.Formatter(
+    '%(asctime)s - %(name)s'
+    '-%(funcName)s()'
+    ': %(message)s'
+)
+
+logger_fmt = logging.Formatter(
+    '%(asctime)s - %(name)s'
+    ': %(message)s'
+)
 
 class ServerLogHandler(logging.Handler):
     def __init__(self, server):

mcw/meson.py

@@ -1,6 +1,7 @@
 import os
 import json
 import subprocess
+import logging
 
 from .ninja import NinjaBackend
 
@@ -28,14 +29,12 @@ def __init__(self, path='meson'):
         self.c_compile_commands = None
         self.c_compile_commands_target = {}
         self.c_default_inc_dirs = {}
+        self.logger = logging.getLogger('Meson')
 
-    def log(self, msg):
-        if isinstance(msg, Exception):
-            self.logger.info(msg, exc_info=msg)
-        else:
-            self.logger.info(msg)
+    def get_logger(self):
+        return self.logger
 
-    def call(self, args, show=False):
+    def call(self, args, show=False) -> str:
         child = subprocess.Popen([self.path] + args, stdout=subprocess.PIPE)
         fulloutput = b''
         while True:
@@ -89,8 +88,10 @@ def get_project_name(self):
     def get_targets(self):
         if not self.c_targets:
             output = self.call(['introspect', '--targets', self.build_dir])
-            self.log('(targets) "%s"' % output)
+            self.logger.debug('(targets) "%s"' % output)
             self.c_targets = json.loads(output)
+            target_names = [ i ['name'] for i in self.c_targets]
+            self.logger.info('(targets) {}'.format(target_names))
         return self.c_targets
 
     def get_target_files(self, target):
@@ -108,9 +109,9 @@ def get_target_files(self, target):
             return self.c_target_files[id]
 
         # Handle meson versions before 0.50.0
-        self.log('(target) "%s"' % id)
+        self.logger.debug('(target) "%s"' % id)
         output = self.call(['introspect', '--target-files', id, self.build_dir])
-        self.log('(target files) "%s"' % output)
+        self.logger.debug('(target files) "%s"' % output)
 
         # Workaround https://github.com/mesonbuild/meson/issues/2783
         if output == '':
@@ -122,14 +123,14 @@ def get_target_files(self, target):
     def get_buildsystem_files(self):
         if not self.c_buildsystem_files:
             output = self.call(['introspect', '--buildsystem-files', self.build_dir])
-            self.log('(buildsystem files) "%s"' % output)
+            self.logger.debug('(buildsystem files) "%s"' % output)
             self.c_buildsystem_files = json.loads(output)
         return self.c_buildsystem_files
 
     def get_project_info(self):
         if not self.c_project_info:
             output = self.call(['introspect', '--projectinfo', self.build_dir])
-            self.log('(project info) "%s"' % output)
+            self.logger.info('(project info) "%s"' % output)
             self.c_project_info = json.loads(output)
         return self.c_project_info
 
@@ -227,10 +228,14 @@ def get_output(self, target):
         return os.path.join(self.build_dir, self.get_target_filename(target))
 
     def get_target_filename(self, target):
-        if self.get_version()[1] >= 50:
-            return target['filename'][0]
+        filename = target['filename']
+
+        if isinstance(filename, list):
+            if len(filename) > 1:
+                self.logger.debug('Target {} has more than 1 filename {}'.format(target['name'], filename))
+            return filename[0]
         else:
-            return target['filename']
+            return filename
 
     def get_options(self):
         meson_options = []

mcw/ninja.py

@@ -44,6 +44,6 @@ def build(self, target):
     def get_target(self, target_name):
         target = next((t for t in self.meson.get_targets() if t['name'] == target_name), None)
         if target:
-            return target['filename']
+            return target['name']
 
         return target_name