conan 2.18.0__tar.gz → 2.19.0__tar.gz

{conan-2.18.0/conan.egg-info → conan-2.19.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: conan
-Version: 2.18.0
+Version: 2.19.0
 Summary: Conan C/C++ package manager
 Home-page: https://conan.io
 Author: JFrog LTD

{conan-2.18.0 → conan-2.19.0}/conan/__init__.py

@@ -2,5 +2,5 @@ from conan.internal.model.conan_file import ConanFile
 from conan.internal.model.workspace import Workspace
 from conan.internal.model.version import Version
 
-__version__ = '2.18.0'
+__version__ = '2.19.0'
 conan_version = Version(__version__)

{conan-2.18.0 → conan-2.19.0}/conan/api/conan_api.py

@@ -22,6 +22,8 @@ from conan.api.subapi.remove import RemoveAPI
 from conan.api.subapi.search import SearchAPI
 from conan.api.subapi.upload import UploadAPI
 from conan.errors import ConanException
+from conan.internal.cache.home_paths import HomePaths
+from conan.internal.hook_manager import HookManager
 from conan.internal.paths import get_conan_user_home
 from conan.internal.api.migrations import ClientMigrator
 from conan.internal.model.version_range import validate_conan_version
@@ -48,10 +50,12 @@ class ConanAPI:
         init_colorama(sys.stderr)
         self.cache_folder = cache_folder or get_conan_user_home()
         self.home_folder = self.cache_folder  # Lets call it home, deprecate "cache"
-        self.migrate()
-
         # This API is depended upon by the subsequent ones, it should be initialized first
         self.config = ConfigAPI(self)
+        _check_conan_version(self)
+
+        self._api_helpers = self._ApiHelpers(self)
+        self.migrate()
 
         self.remotes = RemotesAPI(self)
         self.command = CommandAPI(self)
@@ -60,27 +64,27 @@ class ConanAPI:
         # Get latest refs and list refs of recipes and packages
         self.list = ListAPI(self)
         self.profiles = ProfilesAPI(self)
-        self.install = InstallAPI(self)
-        self.graph = GraphAPI(self)
-        self.export = ExportAPI(self)
+        self.install = InstallAPI(self, self._api_helpers)
+        self.graph = GraphAPI(self, self._api_helpers)
+        self.export = ExportAPI(self, self._api_helpers)
         self.remove = RemoveAPI(self)
         self.new = NewAPI(self)
         self.upload = UploadAPI(self)
         self.download = DownloadAPI(self)
         self.cache = CacheAPI(self)
         self.lockfile = LockfileAPI(self)
-        self.local = LocalAPI(self)
+        self.local = LocalAPI(self, self._api_helpers)
         self.audit = AuditAPI(self)
         # Now, lazy loading of editables
         self.workspace = WorkspaceAPI(self)
-        self.report = ReportAPI(self)
-
-        _check_conan_version(self)
+        self.report = ReportAPI(self, self._api_helpers)
 
     def reinit(self):
         """
         Reinitialize the Conan API. This is useful when the configuration changes.
         """
+        # TODO: Think order of reinitialization for helpers
+        self._api_helpers.reinit()
         self.config.reinit()
         self.remotes.reinit()
         self.local.reinit()
@@ -94,6 +98,14 @@ class ConanAPI:
         migrator = ClientMigrator(self.cache_folder, conan_version)
         migrator.migrate()
 
+    class _ApiHelpers:
+        def __init__(self, conan_api):
+            self._conan_api = conan_api
+            self.hook_manager = HookManager(HomePaths(self._conan_api.home_folder).hooks_path)
+
+        def reinit(self):
+            self.hook_manager.reinit()
+
 
 def _check_conan_version(conan_api):
     required_range_new = conan_api.config.global_conf.get("core:required_conan_version")

{conan-2.18.0 → conan-2.19.0}/conan/api/input.py

@@ -33,11 +33,11 @@ class UserInput:
         :param username If username is specified it only request password"""
         self._raise_if_non_interactive()
         if not username:
-            self._out.write("Remote '%s' username: " % remote_name)
+            self._out.login_msg(f"Remote '{remote_name}' username: ")
             username = self.get_username()
 
-        self._out.write("Please enter a password for user '%s' on remote '%s': "
-                        % (username, remote_name))
+        self._out.login_msg("Please enter a password for "
+                            f"user '{username}' on remote '{remote_name}': ")
         try:
             pwd = self.get_password()
         except ConanException:

{conan-2.18.0 → conan-2.19.0}/conan/api/output.py

@@ -19,7 +19,7 @@ LEVEL_DEBUG = 20  # -vv Closely related to internal implementation details
 LEVEL_TRACE = 10  # -vvv Fine-grained messages with very low-level implementation details
 
 
-class Color(object):
+class Color:
     """ Wrapper around colorama colors that are undefined in importing
     """
     RED = Fore.RED  # @UndefinedVariable
@@ -181,6 +181,11 @@ class ConanOutput:
         self.writeln(f'*{msg: ^48}*', fg=color)
         self.writeln(f"**************************************************\n", fg=color)
 
+    def login_msg(self, msg, newline=False):
+        # unconditional to the error level, this has to show always
+        self._write_message(msg, newline=newline)
+        return self
+
     def _write_message(self, msg, fg=None, bg=None, newline=True):
         if isinstance(msg, dict):
             # For traces we can receive a dict already, we try to transform then into more natural
@@ -189,20 +194,19 @@ class ConanOutput:
             msg = "=> {}".format(msg)
             # msg = json.dumps(msg, sort_keys=True, default=json_encoder)
 
-        ret = ""
         if self._scope:
             if self._color:
-                ret = "{}{}{}:{} ".format(fg or '', bg or '', self.scope, Style.RESET_ALL)
+                ret = f"{fg or ''}{bg or ''}{self._scope}: {msg}{Style.RESET_ALL}"
             else:
-                ret = "{}: ".format(self._scope)
-
-        if self._color:
-            ret += "{}{}{}{}".format(fg or '', bg or '', msg, Style.RESET_ALL)
+                ret = f"{self._scope}: {msg}"
         else:
-            ret += "{}".format(msg)
+            if self._color:
+                ret = f"{fg or ''}{bg or ''}{msg}{Style.RESET_ALL}"
+            else:
+                ret = msg
 
         if newline:
-            ret = "%s\n" % ret
+            ret += "\n"
 
         with self.lock:
             self.stream.write(ret)
@@ -260,7 +264,8 @@ class ConanOutput:
 
     def warning(self, msg, warn_tag=None):
         _treat_as_error = self._warn_tag_matches(warn_tag, self._warnings_as_errors)
-        if self._conan_output_level <= LEVEL_WARNING or (_treat_as_error and self._conan_output_level <= LEVEL_ERROR):
+        if (self._conan_output_level <= LEVEL_WARNING or
+                (_treat_as_error and self._conan_output_level <= LEVEL_ERROR)):
             if self._warn_tag_matches(warn_tag, self._silent_warn_tags):
                 return self
             warn_tag_msg = "" if warn_tag is None else f"{warn_tag}: "

{conan-2.18.0 → conan-2.19.0}/conan/api/subapi/config.py

@@ -30,7 +30,6 @@ class ConfigAPI:
         self.conan_api = conan_api
         self._new_config = None
         self._cli_core_confs = None
-        self.hook_manager = HookManager(HomePaths(conan_api.home_folder).hooks_path)
 
     def home(self):
         return self.conan_api.cache_folder
@@ -236,4 +235,3 @@ class ConfigAPI:
         if self._new_config is not None:
             self._new_config.clear()
             self._populate_global_conf()
-        self.hook_manager = HookManager(HomePaths(self.conan_api.home_folder).hooks_path)

{conan-2.18.0 → conan-2.19.0}/conan/api/subapi/export.py

@@ -10,19 +10,20 @@ from conan.internal.util.files import mkdir
 
 class ExportAPI:
 
-    def __init__(self, conan_api):
+    def __init__(self, conan_api, helpers):
         self.conan_api = conan_api
+        self._helpers = helpers
 
     def export(self, path, name, version, user, channel, lockfile=None, remotes=None):
         ConanOutput().title("Exporting recipe to the cache")
         app = ConanApp(self.conan_api)
-        hook_manager = self.conan_api.config.hook_manager
+        hook_manager = self._helpers.hook_manager
         return cmd_export(app, hook_manager, self.conan_api.config.global_conf, path, name, version,
                           user, channel, graph_lock=lockfile, remotes=remotes)
 
     def export_pkg(self, deps_graph, source_folder, output_folder):
         cache = PkgCache(self.conan_api.cache_folder, self.conan_api.config.global_conf)
-        hook_manager = self.conan_api.config.hook_manager
+        hook_manager = self._helpers.hook_manager
 
         # The graph has to be loaded with build_mode=[ref.name], so that node is not tried
         # to be downloaded from remotes

{conan-2.18.0 → conan-2.19.0}/conan/api/subapi/graph.py

@@ -13,8 +13,9 @@ from conan.api.model import RecipeReference
 
 class GraphAPI:
 
-    def __init__(self, conan_api):
+    def __init__(self, conan_api, helpers):
         self.conan_api = conan_api
+        self._helpers = helpers
 
     def _load_root_consumer_conanfile(self, path, profile_host, profile_build,
                                       name=None, version=None, user=None, channel=None,
@@ -205,7 +206,8 @@ class GraphAPI:
         """
         ConanOutput().title("Computing necessary packages")
         conan_app = ConanBasicApp(self.conan_api)
-        binaries_analyzer = GraphBinariesAnalyzer(conan_app, self.conan_api.config.global_conf)
+        binaries_analyzer = GraphBinariesAnalyzer(conan_app, self.conan_api.config.global_conf,
+                                                  self._helpers.hook_manager)
         binaries_analyzer.evaluate_graph(graph, build_mode, lockfile, remotes, update,
                                          build_modes_test, tested_graph)
 

{conan-2.18.0 → conan-2.19.0}/conan/api/subapi/install.py

@@ -11,8 +11,9 @@ from conan.errors import ConanInvalidConfiguration
 
 class InstallAPI:
 
-    def __init__(self, conan_api):
+    def __init__(self, conan_api, helpers):
         self.conan_api = conan_api
+        self._helpers = helpers
 
     def install_binaries(self, deps_graph, remotes=None):
         """ Install binaries for dependency graph
@@ -21,7 +22,7 @@ class InstallAPI:
         """
         app = ConanBasicApp(self.conan_api)
         installer = BinaryInstaller(app, self.conan_api.config.global_conf, app.editable_packages,
-                                    self.conan_api.config.hook_manager)
+                                    self._helpers.hook_manager)
         install_graph = InstallGraph(deps_graph)
         install_graph.raise_errors()
         install_order = install_graph.install_order()
@@ -35,7 +36,7 @@ class InstallAPI:
         """
         app = ConanBasicApp(self.conan_api)
         installer = BinaryInstaller(app, self.conan_api.config.global_conf, app.editable_packages,
-                                    self.conan_api.config.hook_manager)
+                                    self._helpers.hook_manager)
         installer.install_system_requires(graph, only_info)
 
     def install_sources(self, graph, remotes):
@@ -46,7 +47,7 @@ class InstallAPI:
         """
         app = ConanBasicApp(self.conan_api)
         installer = BinaryInstaller(app, self.conan_api.config.global_conf, app.editable_packages,
-                                    self.conan_api.config.hook_manager)
+                                    self._helpers.hook_manager)
         installer.install_sources(graph, remotes)
 
     # TODO: Look for a better name
@@ -87,7 +88,7 @@ class InstallAPI:
             if gen not in final_generators:
                 final_generators.append(gen)
         conanfile.generators = final_generators
-        hook_manager = self.conan_api.config.hook_manager
+        hook_manager = self._helpers.hook_manager
         write_generators(conanfile, hook_manager, self.conan_api.home_folder,
                          envs_generation=envs_generation)
 

{conan-2.18.0 → conan-2.19.0}/conan/api/subapi/local.py

@@ -14,8 +14,9 @@ from conan.internal.util.files import chdir
 
 class LocalAPI:
 
-    def __init__(self, conan_api):
+    def __init__(self, conan_api, helpers):
         self._conan_api = conan_api
+        self._helpers = helpers
         self.editable_packages = EditablePackages(conan_api.home_folder)
 
     @staticmethod
@@ -93,13 +94,13 @@ class LocalAPI:
         conanfile.folders.set_base_build(None)
         conanfile.folders.set_base_package(None)
 
-        hook_manager = self._conan_api.config.hook_manager
+        hook_manager = self._helpers.hook_manager
         run_source_method(conanfile, hook_manager)
 
     def build(self, conanfile):
         """ calls the 'build()' method of the current (user folder) conanfile.py
         """
-        hook_manager = self._conan_api.config.hook_manager
+        hook_manager = self._helpers.hook_manager
         conanfile.folders.set_base_package(conanfile.folders.base_build)
         conanfile.folders.set_base_pkg_metadata(os.path.join(conanfile.build_folder, "metadata"))
         run_build_method(conanfile, hook_manager)

{conan-2.18.0 → conan-2.19.0}/conan/api/subapi/report.py

@@ -14,8 +14,9 @@ from conan.internal.util.runners import conan_run
 
 
 class ReportAPI:
-    def __init__(self, conan_api):
+    def __init__(self, conan_api, helpers):
         self.conan_api = conan_api
+        self._helpers = helpers
 
     def diff(self, old_reference, new_reference, remotes, old_path=None, new_path=None, cwd=None):
         """
@@ -36,7 +37,8 @@ class ReportAPI:
                 export_ref, cache_path = _export_recipe_from_path(self.conan_api, path_to_conanfile,
                                                                   reference, remotes, cwd)
             exported_path = self.conan_api.local.get_conanfile_path(cache_path, cwd, py=True)
-            _configure_source(self.conan_api, exported_path, export_ref, remotes)
+            _configure_source(self.conan_api, self._helpers.hook_manager, exported_path, export_ref,
+                              remotes)
             return export_ref, cache_path
 
 
@@ -77,7 +79,7 @@ class ReportAPI:
             "dst_prefix": dst_prefix,
         }
 
-def _configure_source(conan_api, conanfile_path, ref, remotes):
+def _configure_source(conan_api, hook_manager, conanfile_path, ref, remotes):
     app = ConanApp(conan_api)
     conanfile = app.loader.load_consumer(conanfile_path, name=ref.name, version=str(ref.version),
                                          user=ref.user, channel=ref.channel, graph_lock=None,
@@ -97,7 +99,7 @@ def _configure_source(conan_api, conanfile_path, ref, remotes):
     conanfile.folders.set_base_source(source_folder)
     conanfile.folders.set_base_export_sources(export_source_folder)
     conanfile.folders.set_base_recipe_metadata(recipe_layout.metadata())
-    config_source(export_source_folder, conanfile, conan_api.config.hook_manager)
+    config_source(export_source_folder, conanfile, hook_manager)
 
 def _get_ref_from_cache_or_remote(conan_api, reference, enabled_remotes):
     ref = RecipeReference.loads(reference)

{conan-2.18.0 → conan-2.19.0}/conan/cli/commands/export_pkg.py

@@ -38,7 +38,6 @@ def export_pkg(conan_api, parser, *args):
 
     cwd = os.getcwd()
     path = conan_api.local.get_conanfile_path(args.path, cwd, py=True)
-    test_conanfile_path = _get_test_conanfile_path(args.test_folder, path)
     overrides = eval(args.lockfile_overrides) if args.lockfile_overrides else None
     lockfile = conan_api.lockfile.get_lockfile(lockfile=args.lockfile, conanfile_path=path,
                                                cwd=cwd, partial=args.lockfile_partial,
@@ -92,6 +91,9 @@ def export_pkg(conan_api, parser, *args):
     lockfile = conan_api.lockfile.update_lockfile(lockfile, deps_graph, args.lockfile_packages,
                                                   clean=args.lockfile_clean)
 
+    test_package_folder = getattr(conanfile, "test_package_folder", None) \
+        if args.test_folder is None else args.test_folder
+    test_conanfile_path = _get_test_conanfile_path(test_package_folder, path)
     if test_conanfile_path:
         from conan.cli.commands.test import run_test
         # same as ``conan create`` the lockfile, and deps graph is the one of the exported-pkg

{conan-2.18.0 → conan-2.19.0}/conan/cli/commands/new.py

@@ -12,7 +12,7 @@ def new(conan_api, parser, *args):
                         "either a predefined built-in or a user-provided one. "
                         "Available built-in templates: basic, cmake_lib, cmake_exe, header_lib, "
                         "meson_lib, meson_exe, msbuild_lib, msbuild_exe, bazel_lib, bazel_exe, "
-                        "autotools_lib, autotools_exe, local_recipes_index, workspace. "
+                        "autotools_lib, autotools_exe, premake_lib, premake_exe, local_recipes_index, workspace. "
                         "E.g. 'conan new cmake_lib -d name=hello -d version=0.1'. "
                         "You can define your own templates too by inputting an absolute path "
                         "as your template, or a path relative to your conan home folder."

{conan-2.18.0 → conan-2.19.0}/conan/cli/formatters/graph/info_graph_html.py

@@ -44,7 +44,7 @@ graph_info_html = r"""
                     <label for="show_package_type">Show package type</label>
                 </div>
                  <div>
-                    <input type="search" placeholder="Search packages..." oninput="searchPackages(this)">
+                    <input type="search" placeholder="Search packages..." oninput="searchPackages(this)" onkeydown="onSearchKeyDown(event)">
                 </div>
                  <div>
                     <input type="search" placeholder="Exclude packages..." title="Add a comma to exclude an additional package" oninput="excludePackages(this)">
@@ -64,6 +64,7 @@ graph_info_html = r"""
             let hide_build = false;
             let hide_test = false;
             let search_pkgs = null;
+            let focus_search = false;
             let excluded_pkgs = null;
             let collapse_packages = false;
             let show_package_type = false;
@@ -135,6 +136,9 @@ graph_info_html = r"""
                         if (patterns.some(pattern => label.match(pattern))) {
                             borderWidth = 3;
                             borderColor = "Magenta";
+                            if (focus_search) {
+                                focus_search = node_id;
+                            }
                         }
                     }
                     if (node.test) {
@@ -312,6 +316,10 @@ graph_info_html = r"""
                 network.setData(data);
                 network.redraw();
                 network.moveTo({position: viewPos, scale: scale});
+                // If we have found a package to focus, we need to move the view
+                if (typeof focus_search === "string") {
+                    network.focus(focus_search, {animation: true, locked: false});
+                }
             }
             function switchBuild() {
                 hide_build = !hide_build;
@@ -325,13 +333,28 @@ graph_info_html = r"""
                 collapse_packages = !collapse_packages;
                 draw();
             }
+            const debounce = (func, delay) => {
+                let timeout;
+                return function(...args) {
+                    clearTimeout(timeout);
+                    timeout = setTimeout(() => func.apply(this, args), delay);
+                };
+            };
+            const debouncedDraw = debounce(draw, 300);
             function searchPackages(e) {
                 search_pkgs = e.value;
-                draw();
+                debouncedDraw();
+            }
+            function onSearchKeyDown(event) {
+                if (event.key === "Enter") {
+                    focus_search = true;
+                    draw();
+                    focus_search = false;
+                }
             }
             function excludePackages(e) {
                 excluded_pkgs = e.value;
-                draw();
+                debouncedDraw();
             }
             function showPackageType(e) {
                 show_package_type = !show_package_type;

{conan-2.18.0 → conan-2.19.0}/conan/cli/formatters/report/diff_html.py

@@ -32,56 +32,70 @@ diff_html = r"""
             }
         </style>
         <script>
+            function debounce(func, delay) {
+                let timeout;
+                return function(...args) {
+                    const context = this;
+                    clearTimeout(timeout);
+                    timeout = setTimeout(() => {
+                        func.apply(context, args);
+                    }, delay);
+                };
+            }
             let includeSearchQuery = "";
             let excludeSearchQuery = "";
 
-            async function onExcludeSearchInput(event) {
-                excludeSearchQuery = event.currentTarget.value.toLowerCase();
-                onSearchInput(event);
-            }
-
-            async function onIncludeSearchInput(event) {
-                includeSearchQuery = event.currentTarget.value.toLowerCase();
-                onSearchInput(event);
-            }
-
             async function onSearchInput(event) {
                 const sidebar = document.querySelectorAll(".sidebar li");
                 const content = document.querySelectorAll(".content .diff-content");
+                const searchingIcon = document.getElementById("searching_icon");
+
+                searchingIcon.style.display = "inline-block";
+
+                let emptySearch = true;
 
                 sidebar.forEach(async function(item) {
                     const text = item.textContent.toLowerCase();
                     const shouldInclude = includeSearchQuery === "" || text.includes(includeSearchQuery);
                     const shouldExclude = excludeSearchQuery !== "" && text.includes(excludeSearchQuery);
+                    const associatedId = item.querySelector("a").getAttribute("href").substring(1)
+                    const contentItem = document.getElementById(associatedId);
 
                     if (shouldInclude) {
                         if (shouldExclude) {
                             item.style.display = "none";
+                            contentItem.style.display = "none";
                         } else {
                             item.style.display = "list-item";
+                            contentItem.style.display = "block";
+                            emptySearch = false;
                         }
                     } else {
                         item.style.display = "none";
+                        contentItem.style.display = "none";
                     }
 
                 });
 
-                content.forEach(async function(item) {
-                    const filename = document.getElementById(item.id + "_filename");
-                    const text = filename.dataset.replacedPaths.toLowerCase();
-                    const shouldInclude = includeSearchQuery === "" || text.includes(includeSearchQuery);
-                    const shouldExclude = excludeSearchQuery !== "" && text.includes(excludeSearchQuery);
+                searchingIcon.style.display = "none";
+                const emptySearchTag = document.getElementById("empty_search");
+                if (emptySearch) {
+                    emptySearchTag.style.display = "block";
+                } else {
+                    emptySearchTag.style.display = "none";
+                }
+            }
 
-                    if (shouldInclude) {
-                        if (shouldExclude) {
-                            item.style.display = "none";
-                        } else {
-                            item.style.display = "block";
-                        }
-                    } else {
-                        item.style.display = "none";
-                    }
-                });
+            const debouncedOnSearchInput = debounce(onSearchInput, 500);
+
+             async function onExcludeSearchInput(event) {
+                excludeSearchQuery = event.currentTarget.value.toLowerCase();
+                debouncedOnSearchInput(event);
+            }
+
+            async function onIncludeSearchInput(event) {
+                includeSearchQuery = event.currentTarget.value.toLowerCase();
+                debouncedOnSearchInput(event);
             }
         </script>
     </head>
@@ -96,10 +110,12 @@ diff_html = r"""
                 <h2>File list:</h2>
                 <input type="text" id="search-include" placeholder="Include search..." oninput="onIncludeSearchInput(event)" />
                 <input type="text" id="search-exclude" placeholder="Exclude search..." oninput="onExcludeSearchInput(event)" />
+                <span id="searching_icon" style="display:none">...</span>
                 <ul>
                     {%- for filename in content.keys() %}
                         <li><a href="#diff_{{- safe_filename(filename) -}}" class="side-link">{{ replace_cache_paths(filename) }}</a></li>
                     {%- endfor %}
+                    <span id="empty_search" style="display:none">No results found</span>
                 </ul>
             </div>
             <div class='content'>

{conan-2.18.0 → conan-2.19.0}/conan/internal/api/detect/detect_api.py

@@ -233,7 +233,7 @@ def detect_libcxx(compiler, version, compiler_exe=None):
         old_path = os.getcwd()
         os.chdir(t)
         try:
-            error, out_str = detect_runner("%s main.cpp -std=c++11" % executable)
+            error, out_str = detect_runner(f'"{executable}" main.cpp -std=c++11')
             if error:
                 if "using libstdc++" in out_str:
                     output.info("gcc C++ standard library: libstdc++")
@@ -482,17 +482,16 @@ def _detect_vs_ide_version():
 def _cc_compiler(compiler_exe="cc"):
     # Try to detect the "cc" linux system "alternative". It could point to gcc or clang
     try:
-        ret, out = detect_runner('%s --version' % compiler_exe)
+        ret, out = detect_runner(f'"{compiler_exe}" --version')
         if ret != 0:
             return None, None, None
         compiler = "clang" if "clang" in out else "gcc"
         # clang and gcc have version after a space, first try to find that to skip extra numbers
         # that might appear in the first line of the output before the version
-        installed_version = re.search(r" ([0-9]+(\.[0-9]+)+)", out)
-        # Try only major but with spaces next
-        installed_version = installed_version or re.search(r" ([0-9]+(\.[0-9]+)?)", out)
+        # There might also be a leading parenthesis that contains build information, so we try to skip it
+        installed_version = re.search(r"(?:\(.*\))? ([0-9]+(\.[0-9]+)*)", out)
         # Fallback to the first number we find optionally followed by other version fields
-        installed_version = installed_version or re.search(r"([0-9]+(\.[0-9]+)?)", out)
+        installed_version = installed_version or re.search(r"([0-9]+(\.[0-9]+)*)", out)
         if installed_version and installed_version.group(1):
             installed_version = installed_version.group(1)
             ConanOutput(scope="detect_api").info("Found cc=%s-%s" % (compiler, installed_version))
@@ -505,13 +504,12 @@ def detect_gcc_compiler(compiler_exe="gcc"):
     try:
         if platform.system() == "Darwin":
             # In Mac OS X check if gcc is a fronted using apple-clang
-            _, out = detect_runner("%s --version" % compiler_exe)
+            _, out = detect_runner(f'"{compiler_exe}" --version')
             out = out.lower()
             if "clang" in out:
                 return None, None, None
 
-        # TODO: Add -dumpfullversion to always return major.minor
-        ret, out = detect_runner('%s -dumpversion' % compiler_exe)
+        ret, out = detect_runner(f'"{compiler_exe}" -dumpversion')
         if ret != 0:
             return None, None, None
         compiler = "gcc"
@@ -524,14 +522,15 @@ def detect_gcc_compiler(compiler_exe="gcc"):
 
 
 def detect_compiler():
-    ConanOutput(scope="detect_api").warning("detect_compiler() is deprecated, use detect_default_compiler()", warn_tag="deprecated")
+    ConanOutput(scope="detect_api").warning("detect_compiler() is deprecated, "
+                                            "use detect_default_compiler()", warn_tag="deprecated")
     compiler, version, _ = detect_default_compiler()
     return compiler, version
 
 
 def detect_intel_compiler(compiler_exe="icx"):
     try:
-        ret, out = detect_runner("%s --version" % compiler_exe)
+        ret, out = detect_runner(f'"{compiler_exe}" --version')
         if ret != 0:
             return None, None
         compiler = "intel-cc"
@@ -545,7 +544,7 @@ def detect_intel_compiler(compiler_exe="icx"):
 
 def detect_suncc_compiler(compiler_exe="cc"):
     try:
-        _, out = detect_runner('%s -V' % compiler_exe)
+        _, out = detect_runner(f'"{compiler_exe}" -V')
         compiler = "sun-cc"
         installed_version = re.search(r"Sun C.*([0-9]+\.[0-9]+)", out)
         if installed_version:
@@ -561,7 +560,7 @@ def detect_suncc_compiler(compiler_exe="cc"):
 
 def detect_clang_compiler(compiler_exe="clang"):
     try:
-        ret, out = detect_runner('%s --version' % compiler_exe)
+        ret, out = detect_runner(f'"{compiler_exe}" --version')
         if ret != 0:
             return None, None, None
         if "Apple" in out:
@@ -651,6 +650,6 @@ def detect_sdk_version(sdk):
     if platform.system() != "Darwin":
         return
     cmd = f'xcrun -sdk {sdk} --show-sdk-version'
-    result = check_output_runner(cmd)
+    _, result = detect_runner(cmd)
     result = result.strip()
     return result

{conan-2.18.0 → conan-2.19.0}/conan/internal/cache/home_paths.py

@@ -20,8 +20,6 @@ class HomePaths:
     def global_conf_path(self):
         return os.path.join(self._home, "global.conf")
 
-    new_config_path = global_conf_path  # for not breaking tests, TODO to remove
-
     @property
     def deployers_path(self):
         deploy = os.path.join(self._home, _EXTENSIONS_FOLDER, "deploy")