conan 2.12.1__tar.gz → 2.13.0__tar.gz

{conan-2.12.1/conan.egg-info → conan-2.13.0}/PKG-INFO

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

{conan-2.12.1 → conan-2.13.0}/conan/__init__.py

@@ -1,5 +1,6 @@
 from conan.internal.model.conan_file import ConanFile
+from conan.internal.model.workspace import Workspace
 from conan.internal.model.version import Version
 
-__version__ = '2.12.1'
+__version__ = '2.13.0'
 conan_version = Version(__version__)

{conan-2.12.1 → conan-2.13.0}/conan/api/model/list.py

@@ -16,9 +16,6 @@ class MultiPackagesList:
     def __init__(self):
         self.lists = {}
 
-    def setdefault(self, key, default):
-        return self.lists.setdefault(key, default)
-
     def __getitem__(self, name):
         try:
             return self.lists[name]
@@ -57,11 +54,6 @@ class MultiPackagesList:
         pkglist.lists = result
         return pkglist
 
-    @staticmethod
-    def from_graph(graph, graph_recipes=None, graph_binaries=None):
-        graph = {"graph": graph.serialize()}
-        return MultiPackagesList._define_graph(graph, graph_recipes, graph_binaries)
-
     @staticmethod
     def load_graph(graphfile, graph_recipes=None, graph_binaries=None):
         if not os.path.isfile(graphfile):

{conan-2.12.1 → conan-2.13.0}/conan/api/model/refs.py

@@ -44,12 +44,6 @@ class RecipeReference:
             result += "#{}".format(self.revision)
         return result
 
-    def repr_reduced(self):
-        result = self.__str__()
-        if self.revision is not None:
-            result += "#{}".format(self.revision[0:4])
-        return result
-
     def repr_humantime(self):
         result = self.repr_notime()
         assert self.timestamp
@@ -236,16 +230,6 @@ class PkgReference:
             result += "#{}".format(self.revision)
         return result
 
-    def repr_reduced(self):
-        if self.ref is None:
-            return ""
-        result = self.ref.repr_reduced()
-        if self.package_id:
-            result += ":{}".format(self.package_id[0:4])
-        if self.revision is not None:
-            result += "#{}".format(self.revision[0:4])
-        return result
-
     def repr_humantime(self):
         result = self.repr_notime()
         assert self.timestamp

{conan-2.12.1 → conan-2.13.0}/conan/api/output.py

@@ -175,18 +175,7 @@ class ConanOutput:
 
         return self
 
-    def rewrite_line(self, line):
-        tmp_color = self._color
-        self._color = False
-        total_size = 70
-        limit_size = total_size // 2 - 3
-        if len(line) > total_size:
-            line = line[0:limit_size] + " ... " + line[-limit_size:]
-        self.write("\r%s%s" % (line, " " * (total_size - len(line))))
-        self.stream.flush()
-        self._color = tmp_color
-
-    def _write_message(self, msg, fg=None, bg=None):
+    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
             # text
@@ -206,8 +195,11 @@ class ConanOutput:
         else:
             ret += "{}".format(msg)
 
+        if newline:
+            ret = "%s\n" % ret
+
         with self.lock:
-            self.stream.write("{}\n".format(ret))
+            self.stream.write(ret)
             self.stream.flush()
 
     def trace(self, msg):

{conan-2.12.1 → conan-2.13.0}/conan/api/subapi/new.py

@@ -111,7 +111,7 @@ class NewAPI:
         ensure_list("tool_requires")
 
         def as_package_name(n):
-            return n.replace("-", "_").replace("+", "_").replace(".", "_")
+            return n.replace("-", "_").replace("+", "_")
 
         def as_name(ref):
             ref = as_package_name(ref)
@@ -119,7 +119,7 @@ class NewAPI:
                 ref = ref[0:ref.index('/')]
             return ref
 
-        definitions["package_name"] = as_package_name(name)
+        definitions["package_name"] = as_package_name(name).replace(".", "_")
         definitions["as_name"] = as_name
         definitions["names"] = lambda x: ", ".join(r.split("/", 1)[0] for r in x)
         if "name" not in definitions:

conan-2.13.0/conan/api/subapi/workspace.py

@@ -0,0 +1,253 @@
+import inspect
+import os
+import shutil
+from pathlib import Path
+
+from conan import ConanFile
+from conan.api.model import RecipeReference
+from conan.api.output import ConanOutput
+from conan.cli import make_abs_path
+from conan.errors import ConanException
+from conan.internal.conan_app import ConanApp
+from conan.internal.model.workspace import Workspace
+from conan.tools.scm import Git
+from conans.client.graph.graph import RECIPE_EDITABLE, DepsGraph, CONTEXT_HOST, RECIPE_VIRTUAL, Node, \
+    RECIPE_CONSUMER
+from conans.client.graph.graph import TransitiveRequirement
+from conans.client.graph.profile_node_definer import consumer_definer
+from conans.client.loader import load_python_file
+from conans.client.source import retrieve_exports_sources
+from conans.util.files import merge_directories
+
+
+def _find_ws_folder():
+    path = Path(os.getcwd())
+    while path.is_dir() and len(path.parts) > 1:  # finish at '/'
+        if (path / "conanws.yml").is_file() or (path / "conanws.py").is_file():
+            return str(path)
+        else:
+            path = path.parent
+
+
+def _load_workspace(ws_folder, conan_api):
+    """ loads a conanfile basic object without evaluating anything, returns the module too
+    """
+    wspy = os.path.join(ws_folder, "conanws.py")
+    if not os.path.isfile(wspy):
+        ConanOutput().info(f"conanws.py doesn't exist in {ws_folder}, using default behavior")
+        assert os.path.exists(os.path.join(ws_folder, "conanws.yml"))
+        ws = Workspace(ws_folder, conan_api)
+    else:
+        try:
+            module, module_id = load_python_file(wspy)
+            ws = _parse_module(module, module_id)
+            ws = ws(ws_folder, conan_api)
+        except ConanException as e:
+            raise ConanException(f"Error loading conanws.py at '{wspy}': {e}")
+    return ws
+
+
+def _parse_module(conanfile_module, module_id):
+    result = None
+    for name, attr in conanfile_module.__dict__.items():
+        if (name.startswith("_") or not inspect.isclass(attr) or
+                attr.__dict__.get("__module__") != module_id):
+            continue
+
+        if issubclass(attr, Workspace) and attr != Workspace:
+            if result is None:
+                result = attr
+            else:
+                raise ConanException("More than 1 Workspace in the file")
+
+    if result is None:
+        raise ConanException("No subclass of Workspace")
+
+    return result
+
+
+class WorkspaceAPI:
+    TEST_ENABLED = False
+
+    def __init__(self, conan_api):
+        self._conan_api = conan_api
+        self._folder = _find_ws_folder()
+        if self._folder:
+            ConanOutput().warning(f"Workspace found: {self._folder}")
+            if (WorkspaceAPI.TEST_ENABLED or os.getenv("CONAN_WORKSPACE_ENABLE")) != "will_break_next":
+                ConanOutput().warning("Workspace ignored as CONAN_WORKSPACE_ENABLE is not set")
+                self._folder = None
+            else:
+                ConanOutput().warning(f"Workspace is a dev-only feature, exclusively for testing")
+                self._ws = _load_workspace(self._folder, conan_api)  # Error if not loading
+
+    @property
+    def name(self):
+        self._check_ws()
+        return self._ws.name()
+
+    def home_folder(self):
+        """
+        @return: The custom defined Conan home/cache folder if defined, else None
+        """
+        if not self._folder:
+            return
+        folder = self._ws.home_folder()
+        if folder is None or os.path.isabs(folder):
+            return folder
+        return os.path.normpath(os.path.join(self._folder, folder))
+
+    def folder(self):
+        """
+        @return: the current workspace folder where the conanws.yml or conanws.py is located
+        """
+        return self._folder
+
+    @property
+    def editable_packages(self):
+        """
+        @return: Returns {RecipeReference: {"path": full abs-path, "output_folder": abs-path}}
+        """
+        if not self._folder:
+            return
+        editables = self._ws.editables()
+        editables = {RecipeReference.loads(r): v.copy() for r, v in editables.items()}
+        for v in editables.values():
+            path = os.path.normpath(os.path.join(self._folder, v["path"], "conanfile.py"))
+            if not os.path.isfile(path):
+                raise ConanException(f"Workspace editable not found: {path}")
+            v["path"] = path
+            if v.get("output_folder"):
+                v["output_folder"] = os.path.normpath(os.path.join(self._folder,
+                                                                   v["output_folder"]))
+        return editables
+
+    @property
+    def products(self):
+        self._check_ws()
+        return self._ws.products()
+
+    def open(self, require, remotes, cwd=None):
+        app = ConanApp(self._conan_api)
+        ref = RecipeReference.loads(require)
+        recipe = app.proxy.get_recipe(ref, remotes, update=False, check_update=False)
+
+        layout, recipe_status, remote = recipe
+        if recipe_status == RECIPE_EDITABLE:
+            raise ConanException(f"Can't open a dependency that is already an editable: {ref}")
+        ref = layout.reference
+        conanfile_path = layout.conanfile()
+        conanfile, module = app.loader.load_basic_module(conanfile_path, remotes=remotes)
+
+        scm = conanfile.conan_data.get("scm") if conanfile.conan_data else None
+        dst_path = os.path.join(cwd or os.getcwd(), ref.name)
+        if scm is None:
+            conanfile.output.warning("conandata doesn't contain 'scm' information\n"
+                                     "doing a local copy!!!")
+            shutil.copytree(layout.export(), dst_path)
+            retrieve_exports_sources(app.remote_manager, layout, conanfile, ref, remotes)
+            export_sources = layout.export_sources()
+            if os.path.exists(export_sources):
+                conanfile.output.warning("There are export-sources, copying them, but the location"
+                                         " might be incorrect, use 'scm' approach")
+                merge_directories(export_sources, dst_path)
+        else:
+            git = Git(conanfile, folder=cwd)
+            git.clone(url=scm["url"], target=ref.name)
+            git.folder = ref.name  # change to the cloned folder
+            git.checkout(commit=scm["commit"])
+        return dst_path
+
+    def _check_ws(self):
+        if not self._folder:
+            raise ConanException("Workspace not defined, please create a "
+                                 "'conanws.py' or 'conanws.yml' file")
+
+    def add(self, path, name=None, version=None, user=None, channel=None, cwd=None,
+            output_folder=None, remotes=None, product=False):
+        """
+        Add a new editable package to the current workspace (the current workspace must exist)
+        @param path: The path to the folder containing the conanfile.py that defines the package
+        @param name: (optional) The name of the package to be added if not defined in recipe
+        @param version:
+        @param user:
+        @param channel:
+        @param cwd:
+        @param output_folder:
+        @param remotes:
+        @param product:
+        @return: The reference of the added package
+        """
+        self._check_ws()
+        full_path = self._conan_api.local.get_conanfile_path(path, cwd, py=True)
+        app = ConanApp(self._conan_api)
+        conanfile = app.loader.load_named(full_path, name, version, user, channel, remotes=remotes)
+        if conanfile.name is None or conanfile.version is None:
+            raise ConanException("Editable package recipe should declare its name and version")
+        ref = RecipeReference(conanfile.name, conanfile.version, conanfile.user, conanfile.channel)
+        ref.validate_ref()
+        output_folder = make_abs_path(output_folder) if output_folder else None
+        # Check the conanfile is there, and name/version matches
+        self._ws.add(ref, full_path, output_folder, product)
+        return ref
+
+    def remove(self, path):
+        self._check_ws()
+        return self._ws.remove(path)
+
+    def info(self):
+        self._check_ws()
+        return {"name": self.name,
+                "folder": self._folder,
+                "products": self.products,
+                "editables": self._ws.editables()}
+
+    def editable_from_path(self, path):
+        editables = self._ws.editables()
+        for ref, info in editables.items():
+            if info["path"].replace("\\", "/") == path:
+                return RecipeReference.loads(ref)
+
+    def collapse_editables(self, deps_graph, profile_host, profile_build):
+        ConanOutput().title(f"Collapsing workspace editables")
+
+        root_class = self._ws.root_conanfile()
+        if root_class is not None:
+            conanfile = root_class("conanws.py base project Conanfile")
+            consumer_definer(conanfile, profile_host, profile_build)
+            root = Node(None, conanfile, context=CONTEXT_HOST, recipe=RECIPE_CONSUMER,
+                        path=self._folder)  # path lets use the conanws.py folder
+            root.should_build = True  # It is a consumer, this is something we are building
+            for field in ("requires", "build_requires", "test_requires", "requirements", "build",
+                          "source", "package"):
+                if getattr(conanfile, field, None):
+                    raise ConanException(f"Conanfile in conanws.py shouldn't have '{field}'")
+        else:
+            ConanOutput().info("Workspace conanfilews.py not found in the workspace folder, "
+                               "using default behavior")
+            conanfile = ConanFile(display_name="cli")
+            consumer_definer(conanfile, profile_host, profile_build)
+            root = Node(ref=None, conanfile=conanfile, context=CONTEXT_HOST, recipe=RECIPE_VIRTUAL)
+
+        result = DepsGraph()  # TODO: We might need to copy more information from the original graph
+        result.add_node(root)
+        for node in deps_graph.nodes[1:]:  # Exclude the current root
+            if node.recipe != RECIPE_EDITABLE:
+                result.add_node(node)
+                continue
+            for r, t in node.transitive_deps.items():
+                if t.node.recipe == RECIPE_EDITABLE:
+                    continue
+                existing = root.transitive_deps.pop(r, None)
+                if existing is None:
+                    root.transitive_deps[r] = t
+                else:
+                    require = existing.require
+                    require.aggregate(r)
+                    root.transitive_deps[require] = TransitiveRequirement(require, t.node)
+
+        # The graph edges must be defined too
+        for r, t in root.transitive_deps.items():
+            result.add_edge(root, t.node, r)
+
+        return result

{conan-2.12.1 → conan-2.13.0}/conan/cli/commands/lock.py

@@ -1,3 +1,4 @@
+from collections import defaultdict
 import os
 
 from conan.api.output import ConanOutput
@@ -6,6 +7,7 @@ from conan.cli.command import conan_command, OnceArgument, conan_subcommand
 from conan.cli import make_abs_path
 from conan.cli.args import common_graph_args, validate_common_graph_args
 from conan.cli.printers.graph import print_graph_packages, print_graph_basic
+from conan.errors import ConanException
 from conan.api.model import RecipeReference
 
 
@@ -172,3 +174,63 @@ def lock_update(conan_api, parser, subparser, *args):
     lockfile.update(requires=args.requires, build_requires=args.build_requires,
                     python_requires=args.python_requires, config_requires=args.config_requires)
     conan_api.lockfile.save_lockfile(lockfile, args.lockfile_out)
+
+
+
+
+@conan_subcommand()
+def lock_upgrade(conan_api, parser, subparser, *args):
+    """
+    (Experimental) Upgrade requires, build-requires or python-requires from an existing lockfile given a conanfile
+    or a reference.
+    """
+
+    common_graph_args(subparser)
+    subparser.add_argument('--update-requires', action="append", help='Update requires from lockfile')
+    subparser.add_argument('--update-build-requires', action="append", help='Update build-requires from lockfile')
+    subparser.add_argument('--update-python-requires', action="append", help='Update python-requires from lockfile')
+    subparser.add_argument('--update-config-requires', action="append", help='Update config-requires from lockfile')
+    subparser.add_argument('--build-require', action='store_true', default=False, help='Whether the provided reference is a build-require')
+    args = parser.parse_args(*args)
+
+    # parameter validation
+    validate_common_graph_args(args)
+
+    if not any([args.update_requires, args.update_build_requires, args.update_python_requires, args.update_config_requires]):
+        raise ConanException("At least one of --update-requires, --update-build-requires, "
+                             "--update-python-requires or --update-config-requires should be specified")
+
+    cwd = os.getcwd()
+    path = conan_api.local.get_conanfile_path(args.path, cwd, py=None) if args.path else None
+    remotes = conan_api.remotes.list(args.remote) if not args.no_remote else []
+    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=True, overrides=overrides)
+    profile_host, profile_build = conan_api.profiles.get_profiles_from_args(args)
+
+    # Remove the lockfile entries that will be updated
+    lockfile = conan_api.lockfile.remove_lockfile(lockfile,
+                                                  requires=args.update_requires,
+                                                  python_requires=args.update_python_requires,
+                                                  build_requires=args.update_build_requires,
+                                                  config_requires=args.update_config_requires)
+    # Resolve new graph
+    if path:
+        graph = conan_api.graph.load_graph_consumer(path, args.name, args.version,
+                                                    args.user, args.channel,
+                                                    profile_host, profile_build, lockfile,
+                                                    remotes, args.update,
+                                                    is_build_require=args.build_require)
+    else:
+        graph = conan_api.graph.load_graph_requires(args.requires, args.tool_requires,
+                                                    profile_host, profile_build, lockfile,
+                                                    remotes, args.update)
+    print_graph_basic(graph)
+    graph.report_graph_error()
+    conan_api.graph.analyze_binaries(graph, args.build, remotes=remotes, update=args.update,
+                                     lockfile=lockfile)
+    print_graph_packages(graph)
+
+    lockfile = conan_api.lockfile.update_lockfile(lockfile, graph, args.lockfile_packages,
+                                                  clean=args.lockfile_clean)
+    conan_api.lockfile.save_lockfile(lockfile, args.lockfile_out or "conan.lock")

{conan-2.12.1 → conan-2.13.0}/conan/cli/commands/new.py

@@ -46,6 +46,7 @@ def new(conan_api, parser, *args):
             definitions[k] = v
 
     files = conan_api.new.get_template(args.template)  # First priority: user folder
+    is_builtin = False
     if not files:  # then, try the templates in the Conan home
         files = conan_api.new.get_home_template(args.template)
     if files:
@@ -53,10 +54,13 @@ def new(conan_api, parser, *args):
     else:
         template_files = conan_api.new.get_builtin_template(args.template)
         non_template_files = {}
+        is_builtin = True
 
     if not template_files and not non_template_files:
         raise ConanException("Template doesn't exist or not a folder: {}".format(args.template))
 
+    if is_builtin and args.template == "workspace":  # hardcoded for the workspace special case
+        definitions["name"] = "liba"
     template_files = conan_api.new.render(template_files, definitions)
 
     # Saving the resulting files

{conan-2.12.1 → conan-2.13.0}/conan/cli/commands/remote.py

@@ -278,7 +278,7 @@ def print_auth_json(results):
 @conan_subcommand(formatters={"text": print_auth, "json": print_auth_json})
 def remote_auth(conan_api, parser, subparser, *args):
     """
-    Authenticate in the defined remotes. Use CONAN_LOGIN* and CONAN_PASSWORD* variables if available.
+    Authenticate in the defined remotes. Use CONAN_LOGIN_USERNAME* and CONAN_PASSWORD* variables if available.
     Ask for username and password interactively in case (re-)authentication is required and there are
     no CONAN_LOGIN* and CONAN_PASSWORD* variables available which could be used.
     Usually you'd use this method over conan remote login for scripting which needs to run in CI
@@ -288,7 +288,7 @@ def remote_auth(conan_api, parser, subparser, *args):
                                           " The pattern uses 'fnmatch' style wildcards.")
     subparser.add_argument("--with-user", action="store_true",
                            help="Only try to auth in those remotes that already "
-                                "have a username or a CONAN_LOGIN_ env-var defined")
+                                "have a username or a CONAN_LOGIN_USERNAME* env-var defined")
     subparser.add_argument("--force", action="store_true",
                            help="Force authentication for anonymous-enabled repositories. "
                                 "Can be used for force authentication in case your Artifactory "

{conan-2.12.1 → conan-2.13.0}/conan/cli/commands/workspace.py

@@ -3,6 +3,7 @@ import os
 
 from conan.api.conan_api import ConanAPI
 from conan.api.output import ConanOutput, cli_out_write
+from conan.api.subapi.workspace import WorkspaceAPI
 from conan.cli import make_abs_path
 from conan.cli.args import add_reference_args, add_common_install_arguments, add_lockfile_args
 from conan.cli.command import conan_command, conan_subcommand
@@ -13,7 +14,7 @@ from conan.errors import ConanException
 
 
 @conan_subcommand(formatters={"text": cli_out_write})
-def workspace_root(conan_api: ConanAPI, parser, subparser, *args):
+def workspace_root(conan_api: ConanAPI, parser, subparser, *args):  # noqa
     """
     Return the folder containing the conanws.py/conanws.yml workspace file
     """
@@ -96,11 +97,10 @@ def _print_workspace_info(data):
 
 
 @conan_subcommand(formatters={"text": _print_workspace_info, "json": print_json})
-def workspace_info(conan_api: ConanAPI, parser, subparser, *args):
+def workspace_info(conan_api: ConanAPI, parser, subparser, *args):  # noqa
     """
     Display info for current workspace
     """
-    parser.parse_args(*args)
     return {"info": conan_api.workspace.info()}
 
 
@@ -134,7 +134,7 @@ def workspace_build(conan_api: ConanAPI, parser, subparser, *args):
         products = [args.path]
     else:  # all products
         products = conan_api.workspace.products
-        if products is None:
+        if not products:
             raise ConanException("There are no products defined in the workspace, can't build\n"
                                  "You can use 'conan build <path> --build=editable' to build")
         ConanOutput().title(f"Building workspace products {products}")
@@ -164,8 +164,62 @@ def workspace_build(conan_api: ConanAPI, parser, subparser, *args):
         conan_api.local.build(conanfile)
 
 
+@conan_subcommand()
+def workspace_install(conan_api: ConanAPI, parser, subparser, *args):
+    """
+    Install the workspace as a monolith, installing only external dependencies to the workspace,
+    generating a single result (generators, etc) for the whole workspace.
+    """
+    subparser.add_argument("-g", "--generator", action="append", help='Generators to use')
+    subparser.add_argument("-of", "--output-folder",
+                           help='The root output folder for generated and build files')
+    subparser.add_argument("--envs-generation", default=None, choices=["false"],
+                           help="Generation strategy for virtual environment files for the root")
+    add_common_install_arguments(subparser)
+    add_lockfile_args(subparser)
+    args = parser.parse_args(*args)
+    # Basic collaborators: remotes, lockfile, profiles
+    remotes = conan_api.remotes.list(args.remote) if not args.no_remote else []
+    overrides = eval(args.lockfile_overrides) if args.lockfile_overrides else None
+    # The lockfile by default if not defined will be read from the root workspace folder
+    ws_folder = conan_api.workspace.folder()
+    lockfile = conan_api.lockfile.get_lockfile(lockfile=args.lockfile, conanfile_path=ws_folder,
+                                               cwd=None,
+                                               partial=args.lockfile_partial, overrides=overrides)
+    profile_host, profile_build = conan_api.profiles.get_profiles_from_args(args)
+    print_profiles(profile_host, profile_build)
+
+    conan_api.workspace.info()  # FIXME: Just to force error if WS not enabled
+    # Build a dependency graph with all editables as requirements
+    editables = conan_api.workspace.editable_packages
+    requires = [ref for ref in editables]
+    if not requires:
+        raise ConanException("This workspace cannot be installed, it doesn't have any editable")
+    deps_graph = conan_api.graph.load_graph_requires(requires, [],
+                                                     profile_host, profile_build, lockfile,
+                                                     remotes, args.build, args.update)
+    deps_graph.report_graph_error()
+    print_graph_basic(deps_graph)
+
+    # Collapsing the graph
+    ws_graph = conan_api.workspace.collapse_editables(deps_graph, profile_host, profile_build)
+    ConanOutput().subtitle("Collapsed graph")
+    print_graph_basic(ws_graph)
+
+    conan_api.graph.analyze_binaries(ws_graph, args.build, remotes=remotes, update=args.update,
+                                     lockfile=lockfile)
+    print_graph_packages(ws_graph)
+    conan_api.install.install_binaries(deps_graph=ws_graph, remotes=remotes)
+    output_folder = make_abs_path(args.output_folder) if args.output_folder else None
+    conan_api.install.install_consumer(ws_graph, args.generator, ws_folder, output_folder,
+                                       envs_generation=args.envs_generation)
+
+
 @conan_command(group="Consumer")
-def workspace(conan_api, parser, *args):
+def workspace(conan_api, parser, *args):  # noqa
     """
     Manage Conan workspaces (group of packages in editable mode)
     """
+    if (WorkspaceAPI.TEST_ENABLED or os.getenv("CONAN_WORKSPACE_ENABLE")) != "will_break_next":
+        raise ConanException("Workspace command disabled without CONAN_WORKSPACE_ENABLE env var,"
+                             "please read the docs about this 'incubating' feature")

{conan-2.12.1 → conan-2.13.0}/conan/cps/cps.py

@@ -115,12 +115,16 @@ class CPS:
         self.description = None
         self.license = None
         self.website = None
+        self.prefix = None
 
     def serialize(self):
-        cps = {"cps_version": "0.12.0",
+        cps = {"cps_version": "0.13.0",
                "name": self.name,
                "version": self.version}
 
+        if self.prefix is not None:
+            cps["prefix"] = self.prefix
+
         # Supplemental
         for data in "license", "description", "website":
             if getattr(self, data, None):
@@ -143,6 +147,7 @@ class CPS:
     def deserialize(data):
         cps = CPS()
         cps.name = data.get("name")
+        cps.prefix = data.get("prefix")
         cps.version = data.get("version")
         cps.license = data.get("license")
         cps.description = data.get("description")
@@ -157,6 +162,7 @@ class CPS:
     @staticmethod
     def from_conan(dep):
         cps = CPS(dep.ref.name, str(dep.ref.version))
+        cps.prefix = dep.package_folder.replace("\\", "/")
         # supplemental
         cps.license = dep.license
         cps.description = dep.description

{conan-2.12.1 → conan-2.13.0}/conan/internal/api/install/generators.py

@@ -11,6 +11,7 @@ from conans.util.files import save, mkdir, chdir
 
 _generators = {"CMakeToolchain": "conan.tools.cmake",
                "CMakeDeps": "conan.tools.cmake",
+               "CMakeConfigDeps": "conan.tools.cmake",
                "MesonToolchain": "conan.tools.meson",
                "MSBuildDeps": "conan.tools.microsoft",
                "MSBuildToolchain": "conan.tools.microsoft",

{conan-2.12.1 → conan-2.13.0}/conan/internal/api/new/cmake_lib.py

@@ -115,7 +115,7 @@ source_cpp = r"""#include <iostream>
 void {{package_name}}(){
     {% if requires is defined -%}
     {% for require in requires -%}
-    {{ as_name(require) }}();
+    {{ as_name(require).replace(".", "_") }}();
     {% endfor %}
     {%- endif %}