Feature/profile contexts

conan/api/subapi/profiles.py

@@ -64,12 +64,12 @@ def get_profiles_from_args(self, args):
         cwd = os.getcwd()
         profile_build = self._get_profile(build_profiles, args.settings_build, args.options_build,
                                           args.conf_build, cwd, cache_settings,
-                                          profile_plugin, global_conf)
+                                          profile_plugin, global_conf, context="build")
         profile_host = self._get_profile(host_profiles, args.settings_host, args.options_host, args.conf_host,
-                                         cwd, cache_settings, profile_plugin, global_conf)
+                                         cwd, cache_settings, profile_plugin, global_conf, context="host")
         return profile_host, profile_build
 
-    def get_profile(self, profiles, settings=None, options=None, conf=None, cwd=None):
+    def get_profile(self, profiles, settings=None, options=None, conf=None, cwd=None, context=None):
         """ Computes a Profile as the result of aggregating all the user arguments, first it
         loads the "profiles", composing them in order (last profile has priority), and
         finally adding the individual settings, options (priority over the profiles)
@@ -81,13 +81,13 @@ def get_profile(self, profiles, settings=None, options=None, conf=None, cwd=None
         profile_plugin = self._load_profile_plugin()
 
         profile = self._get_profile(profiles, settings, options, conf, cwd, cache_settings,
-                                    profile_plugin, global_conf)
+                                    profile_plugin, global_conf, context=context)
         return profile
 
     def _get_profile(self, profiles, settings, options, conf, cwd, cache_settings,
-                     profile_plugin, global_conf):
+                     profile_plugin, global_conf, context):
         loader = ProfileLoader(self._conan_api.cache_folder)
-        profile = loader.from_cli_args(profiles, settings, options, conf, cwd)
+        profile = loader.from_cli_args(profiles, settings, options, conf, cwd, context)
         if profile_plugin is not None:
             try:
                 profile_plugin(profile)

conan/internal/api/profile/profile_loader.py

@@ -80,7 +80,7 @@ class ProfileLoader:
     def __init__(self, cache_folder):
         self._home_paths = HomePaths(cache_folder)
 
-    def from_cli_args(self, profiles, settings, options, conf, cwd):
+    def from_cli_args(self, profiles, settings, options, conf, cwd, context=None):
         """ Return a Profile object, as the result of merging a potentially existing Profile
         file and the args command-line arguments
         """
@@ -89,20 +89,20 @@ def from_cli_args(self, profiles, settings, options, conf, cwd):
 
         result = Profile()
         for p in profiles:
-            tmp = self.load_profile(p, cwd)
+            tmp = self.load_profile(p, cwd, context)
             result.compose_profile(tmp)
 
         args_profile = _profile_parse_args(settings, options, conf)
         result.compose_profile(args_profile)
         return result
 
-    def load_profile(self, profile_name, cwd=None):
+    def load_profile(self, profile_name, cwd=None, context=None):
         # TODO: This can be made private, only used in testing now
         cwd = cwd or os.getcwd()
-        profile = self._load_profile(profile_name, cwd)
+        profile = self._load_profile(profile_name, cwd, context)
         return profile
 
-    def _load_profile(self, profile_name, cwd):
+    def _load_profile(self, profile_name, cwd, context):
         """ Will look for "profile_name" in disk if profile_name is absolute path,
         in current folder if path is relative or in the default folder otherwise.
         return: a Profile object
@@ -117,31 +117,32 @@ def _load_profile(self, profile_name, cwd):
         # All profiles will be now rendered with jinja2 as first pass
         base_path = os.path.dirname(profile_path)
         file_path = os.path.basename(profile_path)
-        context = {"platform": platform,
+        renderc = {"platform": platform,
                    "os": os,
                    "subprocess": subprocess,
                    "profile_dir": base_path,
                    "profile_name": file_path,
                    "conan_version": conan_version,
-                   "detect_api": detect_api}
+                   "detect_api": detect_api,
+                   "context": context}
 
         # Always include the root Conan home "profiles" folder as secondary route for loading
         # imports and includes from jinja2 templates.
         loader_paths = [base_path, profiles_folder]
 
         try:
             rtemplate = Environment(loader=FileSystemLoader(loader_paths)).from_string(text)
-            text = rtemplate.render(context)
+            text = rtemplate.render(renderc)
         except Exception as e:
             raise ConanException(f"Error while rendering the profile template file '{profile_path}'. "
                                  f"Check your Jinja2 syntax: {str(e)}")
 
         try:
-            return self._recurse_load_profile(text, profile_path)
+            return self._recurse_load_profile(text, profile_path, context)
         except ConanException as exc:
             raise ConanException("Error reading '%s' profile: %s" % (profile_name, exc))
 
-    def _recurse_load_profile(self, text, profile_path):
+    def _recurse_load_profile(self, text, profile_path, context):
         """ Parse and return a Profile object from a text config like representation.
             cwd is needed to be able to load the includes
         """
@@ -153,7 +154,7 @@ def _recurse_load_profile(self, text, profile_path):
             # from parent profiles
             for include in profile_parser.includes:
                 # Recursion !!
-                profile = self._load_profile(include, cwd)
+                profile = self._load_profile(include, cwd, context)
                 inherited_profile.compose_profile(profile)
 
             # Current profile before update with parents (but parent variables already applied)

test/integration/configuration/test_profile_jinja.py

@@ -1,3 +1,4 @@
+import json
 import platform
 import textwrap
 import os
@@ -339,3 +340,57 @@ def generate(self):
     assert "conanfile.py (mypkg/0.1): user.conf:key=2!!!!" in client.out
     assert "conanfile.py (mypkg/0.1): os=Windows!!" in client.out
     assert "conanfile.py (mypkg/0.1): arch=x86!!" in client.out
+
+
+def test_profile_jinja_context():
+    """
+        Test the ``context=build/host`` injection
+    """
+    c = TestClient()
+    tpl1 = textwrap.dedent("""
+        [conf]
+        {% if context == "host" %}
+        user.profile:common = myhost
+        {% elif context == "build" %}
+        user.profile:common = mybuild
+        {% else %}
+        user.profile:common= nocontext
+        [settings]
+        os = Linux
+        {% endif %}
+        """)
+    tpl2 = textwrap.dedent("""
+        include(common)
+        [conf]
+        {% if context == "host" %}
+        user.profile:base = myhost
+        {% elif context == "build" %}
+        user.profile:base = mybuild
+        {% else %}
+        user.profile:base = nocontext
+        [settings]
+        arch = x86
+        {% endif %}
+        """)
+
+    c.save({"common": tpl1,
+            "base": tpl2})
+
+    c.run("profile show -pr:a=base --format=json")
+    profiles = json.loads(c.stdout)
+    assert profiles["host"]["conf"] == {"user.profile:common": "myhost",
+                                        "user.profile:base": "myhost"}
+    assert profiles["build"]["conf"] == {"user.profile:common": "mybuild",
+                                         "user.profile:base": "mybuild"}
+
+    # Now lets test when profile is neither build/host, like when used in ``conan list``
+    c.save({"conanfile.py": GenConanfile("pkg", "0.1").with_settings("os", "arch")})
+    c.run("create . -s os=Linux -s arch=x86")
+    c.run("create . -s os=Windows -s arch=armv8")
+
+    # This will pick the Linux+x86 package binary
+    c.run("list *:* --filter-profile=base")
+    assert "os: Windows" not in c.out
+    assert "arch: armv8" not in c.out
+    assert "os: Linux" in c.out
+    assert "arch: x86" in c.out