Update powershell conf to select from powershell and pwsh

conan/tools/env/environment.py

@@ -3,6 +3,7 @@
 from collections import OrderedDict
 from contextlib import contextmanager
 
+from conan.api.output import ConanOutput
 from conan.internal.api.install.generators import relativize_paths
 from conans.client.subsystems import deduce_subsystem, WINDOWS, subsystem_path
 from conan.errors import ConanException
@@ -14,7 +15,7 @@ class _EnvVarPlaceHolder:
     pass
 
 
-def environment_wrap_command(env_filenames, env_folder, cmd, subsystem=None,
+def environment_wrap_command(conanfile, env_filenames, env_folder, cmd, subsystem=None,
                              accepted_extensions=None):
     if not env_filenames:
         return cmd
@@ -51,22 +52,24 @@ def environment_wrap_command(env_filenames, env_folder, cmd, subsystem=None,
         raise ConanException("Cannot wrap command with different envs,"
                              "{} - {}".format(bats+ps1s, shs))
 
+    powershell = conanfile.conf.get("tools.env.virtualenv:powershell") or "powershell.exe"
+    powershell = "powershell.exe" if powershell is True else powershell
+
     if bats:
         launchers = " && ".join('"{}"'.format(b) for b in bats)
         if ps1s:
-            ps1_launchers = " ; ".join('"&\'{}\'"'.format(f) for f in ps1s)
+            ps1_launchers = f'{powershell} -Command "' + " ; ".join('&\'{}\''.format(f) for f in ps1s) + '"'
             cmd = cmd.replace('"', "'")
-            return '{} && powershell.exe {} ; cmd /c {}'.format(launchers, ps1_launchers, cmd)
+            return '{} && {} ; cmd /c {}'.format(launchers, ps1_launchers, cmd)
         else:
             return '{} && {}'.format(launchers, cmd)
     elif shs:
         launchers = " && ".join('. "{}"'.format(f) for f in shs)
         return '{} && {}'.format(launchers, cmd)
     elif ps1s:
-        # TODO: at the moment it only works with path without spaces
-        launchers = " ; ".join('"&\'{}\'"'.format(f) for f in ps1s)
+        ps1_launchers = f'{powershell} -Command "' + " ; ".join('&\'{}\''.format(f) for f in ps1s) + '"'
         cmd = cmd.replace('"', "'")
-        return 'powershell.exe {} ; cmd /c {}'.format(launchers, cmd)
+        return '{} ; cmd /c {}'.format(ps1_launchers, cmd)
     else:
         return cmd
 
@@ -523,7 +526,8 @@ def save_sh(self, file_location, generate_deactivate=True):
     def save_script(self, filename):
         """
         Saves a script file (bat, sh, ps1) with a launcher to set the environment.
-        If the conf "tools.env.virtualenv:powershell" is set to True it will generate powershell
+        If the conf "tools.env.virtualenv:powershell" is not an empty string
+        it will generate powershell
         launchers if Windows.
 
         :param filename: Name of the file to generate. If the extension is provided, it will generate
@@ -536,7 +540,18 @@ def save_script(self, filename):
             is_ps1 = ext == ".ps1"
         else:  # Need to deduce it automatically
             is_bat = self._subsystem == WINDOWS
-            is_ps1 = self._conanfile.conf.get("tools.env.virtualenv:powershell", check_type=bool)
+            try:
+                is_ps1 = self._conanfile.conf.get("tools.env.virtualenv:powershell", check_type=bool)
+                ConanOutput().warning(
+                    "Boolean values for 'tools.env.virtualenv:powershell' are deprecated. "
+                    "Please specify 'powershell.exe' or 'pwsh' instead, appending arguments if needed "
+                    "(for example: 'powershell.exe -argument'). "
+                    "To unset this configuration, use `tools.env.virtualenv:powershell=!`, which matches "
+                    "the previous 'False' behavior.",
+                    warn_tag="deprecated"
+                )
+            except ConanException:
+                is_ps1 = self._conanfile.conf.get("tools.env.virtualenv:powershell", check_type=str)
             if is_ps1:
                 filename = filename + ".ps1"
                 is_bat = False

conan/tools/microsoft/visual.py

@@ -1,6 +1,7 @@
 import os
 import textwrap
 
+from conan.api.output import ConanOutput
 from conan.internal import check_duplicated_generator
 from conan.internal.api.detect.detect_vs import vs_installation_path
 from conan.errors import ConanException, ConanInvalidConfiguration
@@ -155,7 +156,18 @@ def generate(self, scope="build"):
         create_env_script(conanfile, content, conan_vcvars_bat, scope)
         _create_deactivate_vcvars_file(conanfile, conan_vcvars_bat)
 
-        is_ps1 = conanfile.conf.get("tools.env.virtualenv:powershell", check_type=bool, default=False)
+        try:
+            is_ps1 = self._conanfile.conf.get("tools.env.virtualenv:powershell", check_type=bool)
+            ConanOutput().warning(
+                "Boolean values for 'tools.env.virtualenv:powershell' are deprecated. "
+                "Please specify 'powershell.exe' or 'pwsh' instead, appending arguments if needed "
+                "(for example: 'powershell.exe -argument'). "
+                "To unset this configuration, use `tools.env.virtualenv:powershell=!`, which matches "
+                "the previous 'False' behavior.",
+                warn_tag="deprecated"
+            )
+        except ConanException:
+            is_ps1 = self._conanfile.conf.get("tools.env.virtualenv:powershell", check_type=str)
         if is_ps1:
             content_ps1 = textwrap.dedent(rf"""
             if (-not $env:VSCMD_ARG_VCVARS_VER){{

conans/client/subsystems.py

@@ -43,19 +43,18 @@ def command_env_wrapper(conanfile, command, envfiles, envfiles_folder, scope="bu
 
     active = conanfile.conf.get("tools.microsoft.bash:active", check_type=bool)
     subsystem = conanfile.conf.get("tools.microsoft.bash:subsystem")
-
     if platform.system() == "Windows" and (
             (conanfile.win_bash and scope == "build") or
             (conanfile.win_bash_run and scope == "run")):
         if subsystem is None:
             raise ConanException("win_bash/win_bash_run defined but no "
                                  "tools.microsoft.bash:subsystem")
         if active:
-            wrapped_cmd = environment_wrap_command(envfiles, envfiles_folder, command)
+            wrapped_cmd = environment_wrap_command(conanfile, envfiles, envfiles_folder, command)
         else:
             wrapped_cmd = _windows_bash_wrapper(conanfile, command, envfiles, envfiles_folder)
     else:
-        wrapped_cmd = environment_wrap_command(envfiles, envfiles_folder, command)
+        wrapped_cmd = environment_wrap_command(conanfile, envfiles, envfiles_folder, command)
     return wrapped_cmd
 
 
@@ -94,12 +93,12 @@ def _windows_bash_wrapper(conanfile, command, env, envfiles_folder):
         env.append(path)
 
     wrapped_shell = '"%s"' % shell_path if " " in shell_path else shell_path
-    wrapped_shell = environment_wrap_command(env, envfiles_folder, wrapped_shell,
+    wrapped_shell = environment_wrap_command(conanfile, env, envfiles_folder, wrapped_shell,
                                              accepted_extensions=("bat", "ps1"))
 
     # Wrapping the inside_command enable to prioritize our environment, otherwise /usr/bin go
     # first and there could be commands that we want to skip
-    wrapped_user_cmd = environment_wrap_command(env, envfiles_folder, command,
+    wrapped_user_cmd = environment_wrap_command(conanfile, env, envfiles_folder, command,
                                                 accepted_extensions=("sh", ))
     wrapped_user_cmd = _escape_windows_cmd(wrapped_user_cmd)
     # according to https://www.msys2.org/wiki/Launchers/, it is necessary to use --login shell

test/functional/layout/test_editable_cmake.py

@@ -3,6 +3,7 @@
 
 import pytest
 
+from conan.test.utils.mocks import ConanFileMock
 from conan.tools.env.environment import environment_wrap_command
 from conan.test.assets.pkg_cmake import pkg_cmake, pkg_cmake_app
 from conan.test.assets.sources import gen_function_cpp
@@ -115,11 +116,11 @@ def build_dep():
     def run_pkg(msg):
         host_arch = c.get_default_host_profile().settings['arch']
         # FIXME: This only works with ``--install-folder``, layout() will break this
-        cmd_release = environment_wrap_command(f"conanrunenv-release-{host_arch}", c.current_folder,
+        cmd_release = environment_wrap_command(ConanFileMock(), f"conanrunenv-release-{host_arch}", c.current_folder,
                                                "dep_app",)
         c.run_command(cmd_release)
         assert "{}: Release!".format(msg) in c.out
-        cmd_release = environment_wrap_command(f"conanrunenv-debug-{host_arch}", c.current_folder,
+        cmd_release = environment_wrap_command(ConanFileMock(), f"conanrunenv-debug-{host_arch}", c.current_folder,
                                                "dep_app", )
         c.run_command(cmd_release)
         assert "{}: Debug!".format(msg) in c.out

test/functional/toolchains/cmake/cmakedeps/test_cmakedeps_transitivity.py

@@ -4,6 +4,7 @@
 
 import pytest
 
+from conan.test.utils.mocks import ConanFileMock
 from conan.tools.env.environment import environment_wrap_command
 from conan.test.assets.cmake import gen_cmakelists
 from conan.test.assets.sources import gen_function_cpp
@@ -79,7 +80,7 @@ def build(self):
             "conanfile.py": conanfile}, clean_first=True)
 
     c.run("build .")
-    command = environment_wrap_command("conanrun", c.current_folder, ".\\Release\\myapp.exe")
+    command = environment_wrap_command(ConanFileMock(), "conanrun", c.current_folder, ".\\Release\\myapp.exe")
     c.run_command(command)
     assert "matrix/1.0: Hello World Release!" in c.out
 
@@ -116,7 +117,7 @@ def build(self):
             "conanfile.py": conanfile}, clean_first=True)
 
     c.run("build . ")
-    command = environment_wrap_command("conanrun", c.current_folder, ".\\Release\\myapp.exe")
+    command = environment_wrap_command(ConanFileMock(), "conanrun", c.current_folder, ".\\Release\\myapp.exe")
     c.run_command(command)
     assert "matrix/1.0: Hello World Release!" in c.out
 

test/functional/toolchains/cmake/test_cmake_and_no_soname_flag.py

@@ -57,7 +57,7 @@ def test_no_soname_flag(nosoname_property):
     client.run("install --requires=app/0.1@ -o nosoname*:shared=True -o lib_b/*:shared=True -g VirtualRunEnv")
     # This only finds "app" executable because the "app/0.1" is declaring package_type="application"
     # otherwise, run=None and nothing can tell us if the conanrunenv should have the PATH.
-    command = environment_wrap_command("conanrun", client.current_folder, "app")
+    command = environment_wrap_command(ConanFileMock(),"conanrun", client.current_folder, "app")
 
     # If `nosoname_property` is False, and we have a library without the SONAME flag,
     # then it should fail

test/functional/toolchains/cmake/test_shared_cmake.py

@@ -4,6 +4,7 @@
 
 import pytest
 
+from conan.test.utils.mocks import ConanFileMock
 from conan.tools.env.environment import environment_wrap_command
 from conan.test.assets.pkg_cmake import pkg_cmake, pkg_cmake_app, pkg_cmake_test
 from conan.test.utils.tools import TestClient
@@ -35,7 +36,7 @@ def _check_install_run(client):
                "-g VirtualRunEnv")
     # This only finds "app" executable because the "app/0.1" is declaring package_type="application"
     # otherwise, run=None and nothing can tell us if the conanrunenv should have the PATH.
-    command = environment_wrap_command("conanrun", client.current_folder, "app")
+    command = environment_wrap_command(ConanFileMock(), "conanrun", client.current_folder, "app")
 
     client.run_command(command)
     assert "main: Release!" in client.out
@@ -124,7 +125,7 @@ def test_shared_cmake_toolchain_components():
     client.run("install --requires=app/0.1@ -o chat*:shared=True -o hello/*:shared=True -g VirtualRunEnv")
     # This only finds "app" executable because the "app/0.1" is declaring package_type="application"
     # otherwise, run=None and nothing can tell us if the conanrunenv should have the PATH.
-    command = environment_wrap_command("conanrun", client.current_folder, "app")
+    command = environment_wrap_command(ConanFileMock(), "conanrun", client.current_folder, "app")
 
     client.run_command(command)
     assert "main: Release!" in client.out
@@ -143,7 +144,7 @@ def test_shared_cmake_toolchain_components():
     client.run("install --requires=app/0.1@ -o chat*:shared=True -o hello/*:shared=True -g VirtualRunEnv")
     # This only finds "app" executable because the "app/0.1" is declaring package_type="application"
     # otherwise, run=None and nothing can tell us if the conanrunenv should have the PATH.
-    command = environment_wrap_command("conanrun", client.current_folder, "app")
+    command = environment_wrap_command(ConanFileMock(), "conanrun", client.current_folder, "app")
 
     client.run_command(command)
     assert "main: Release!" in client.out

test/functional/toolchains/env/test_virtualenv_powershell.py

@@ -7,8 +7,10 @@
 from conan.test.assets.cmake import gen_cmakelists
 from conan.test.assets.sources import gen_function_cpp
 from conan.test.assets.genconanfile import GenConanfile
+from conan.test.utils.mocks import ConanFileMock
 from conan.test.utils.test_files import temp_folder
 from conan.test.utils.tools import TestClient
+from conan.tools.env.environment import environment_wrap_command
 from conans.util.files import save
 
 
@@ -28,7 +30,7 @@ def package_info(self):
     """
     client.save({"conanfile.py": conanfile})
     client.run("create .")
-    save(client.cache.new_config_path, "tools.env.virtualenv:powershell=True\n")
+    save(client.cache.new_config_path, "tools.env.virtualenv:powershell=powershell.exe\n")
     return client
 
 
@@ -73,7 +75,8 @@ def build(self):
 
 
 @pytest.mark.skipif(platform.system() != "Windows", reason="Requires Windows powershell")
-def test_virtualenv_test_package():
+@pytest.mark.parametrize("powershell", [True, "powershell.exe", "pwsh"])
+def test_virtualenv_test_package(powershell):
     """ The test_package could crash if not cleaning correctly the test_package
     output folder. This will still crassh if the layout is not creating different build folders
     https://github.com/conan-io/conan/issues/12764
@@ -110,15 +113,16 @@ def test(self):
     assert "MYVC_CUSTOMVAR1=PATATA1" in client.out
     assert "MYVC_CUSTOMVAR2=PATATA2" in client.out
     # This was crashing because the .ps1 of test_package was not being cleaned
-    client.run("create . -c tools.env.virtualenv:powershell=True")
+    client.run(f"create . -c tools.env.virtualenv:powershell={powershell}")
     assert "hello world" in client.out
     assert "MYENV!!!" in client.out
     assert "MYPS1!!!!" in client.out
     assert "MYVC_CUSTOMVAR1=PATATA1" in client.out
     assert "MYVC_CUSTOMVAR2=PATATA2" in client.out
 
 @pytest.mark.skipif(platform.system() != "Windows", reason="Requires Windows powershell")
-def test_vcvars():
+@pytest.mark.parametrize("powershell", [True, "powershell.exe", "pwsh"])
+def test_vcvars(powershell):
     client = TestClient()
     conanfile = textwrap.dedent(r"""
         from conan import ConanFile
@@ -141,15 +145,15 @@ def build(self):
     hello_cpp = gen_function_cpp(name="main")
     cmakelists = gen_cmakelists(appname="hello", appsources=["hello.cpp"])
     client.save({"conanfile.py": conanfile, "hello.cpp": hello_cpp, "CMakeLists.txt": cmakelists})
-
-    client.run("build . -c tools.env.virtualenv:powershell=True -c tools.cmake.cmaketoolchain:generator=Ninja")
-    client.run_command(r'powershell.exe ".\build\Release\generators\conanbuild.ps1; dir env:"')
+    powershell_exe = "powershell.exe" if powershell == "powershell" else "pwsh"
+    client.run(f"build . -c tools.env.virtualenv:powershell={powershell} -c tools.cmake.cmaketoolchain:generator=Ninja")
+    client.run_command(rf'{powershell_exe} -Command ".\build\Release\generators\conanbuild.ps1; dir env:"')
     #check the conanbuid.ps1 activation message
     assert "conanvcvars.ps1: Activated environment" in client.out
     #check that the new env variables are set
     assert "VSCMD_ARG_VCVARS_VER" in client.out
 
-    client.run_command(r'powershell.exe ".\build\Release\generators\conanvcvars.ps1"')
+    client.run_command(rf'{powershell_exe} -Command ".\build\Release\generators\conanvcvars.ps1"')
     assert client.out.strip() == "conanvcvars.ps1: Activated environment"
 
     conanbuild = client.load(r".\build\Release\generators\conanbuild.ps1")
@@ -158,3 +162,52 @@ def build(self):
     assert "conanvcvars.ps1" in conanbuild
     #check that the conanvcvars.ps1 is setting the environment
     assert "conanvcvars.bat&set" in vcvars_ps1
+
+
+
+@pytest.mark.skipif(platform.system() != "Windows", reason="Test for powershell")
+@pytest.mark.parametrize("powershell", [True, "powershell.exe", "pwsh", '"powershell.exe -NoProfile"', '"pwsh -NoProfile"'])
+def test_concatenate_build_and_run_env(powershell):
+    # this tests that if we have both build and run env, they are concatenated correctly when using
+    # powershell
+    client = TestClient(path_with_spaces=True)
+    compiler_bat = "@echo off\necho MYTOOL {}!!\n"
+    conanfile = textwrap.dedent("""\
+        import os
+        from conan import ConanFile
+        from conan.tools.files import copy
+        class Pkg(ConanFile):
+            exports_sources = "*"
+            package_type = "application"
+            def package(self):
+                copy(self, "*", self.build_folder, os.path.join(self.package_folder, "bin"))
+        """)
+
+    num_deps = 2
+    for i in range(num_deps):
+        client.save({"conanfile.py": conanfile,
+                     "mycompiler{}.bat".format(i): compiler_bat.format(i)})
+        client.run("create . --name=pkg{} --version=0.1".format(i))
+
+    conanfile = textwrap.dedent("""\
+        from conan import ConanFile
+        class Pkg(ConanFile):
+            settings = "os"
+            tool_requires = "pkg0/0.1"
+            requires = "pkg1/0.1"
+            generators = "VirtualBuildEnv", "VirtualRunEnv"
+        """)
+
+    client.save({"conanfile.py": conanfile}, clean_first=True)
+    client.run(f"install . -c tools.env.virtualenv:powershell={powershell}")
+    conanfile = ConanFileMock()
+    conanfile.conf.define("tools.env.virtualenv:powershell", powershell)
+    cmd = environment_wrap_command(conanfile,["conanrunenv", "conanbuildenv"],
+                                   client.current_folder,"mycompiler0.bat")
+    client.run_command(cmd)
+    assert "MYTOOL 0!!" in client.out
+
+    cmd = environment_wrap_command(conanfile,["conanrunenv", "conanbuildenv"],
+                                   client.current_folder,"mycompiler1.bat")
+    client.run_command(cmd)
+    assert "MYTOOL 1!!" in client.out

test/functional/toolchains/gnu/autotools/test_basic.py

@@ -6,6 +6,7 @@
 
 import pytest
 
+from conan.test.utils.mocks import ConanFileMock
 from conan.tools.env.environment import environment_wrap_command
 from conan.test.assets.autotools import gen_makefile_am, gen_configure_ac, gen_makefile
 from conan.test.assets.genconanfile import GenConanfile
@@ -96,7 +97,7 @@ def build(self):
                  "profile": profile}, clean_first=True)
 
     client.run("install . --profile=profile")
-    cmd = environment_wrap_command(["conanbuildenv",
+    cmd = environment_wrap_command(ConanFileMock(), ["conanbuildenv",
                                     "conanautotoolstoolchain",
                                     "conanautotoolsdeps"], client.current_folder, make_program)
     client.run_command(cmd)