Feature/environment propagate

.gitignore

@@ -7,7 +7,6 @@ __pycache__/
 
 # Distribution / packaging
 .Python
-env/
 build/
 develop-eggs/
 dist/

conan/tools/env/__init__.py

@@ -0,0 +1,2 @@
+from conan.tools.env.environment import Environment
+from conan.tools.env.virtualenv import VirtualEnv

conan/tools/env/environment.py

@@ -0,0 +1,230 @@
+import fnmatch
+import os
+import textwrap
+from collections import OrderedDict
+
+from conans.errors import ConanException
+from conans.util.files import save
+
+_ENV_VAR_PLACEHOLDER = "$PREVIOUS_ENV_VAR_VALUE%"
+_PATHSEP = "$CONAN_PATHSEP%"
+
+
+class Environment:
+    def __init__(self):
+        # TODO: Maybe we need to pass conanfile to get the [conf]
+        # It being ordered allows for Windows case-insensitive composition
+        self._values = OrderedDict()  # {var_name: [] of values, including separators}
+
+    def vars(self):
+        return list(self._values.keys())
+
+    def value(self, name, placeholder="{}", pathsep=os.pathsep):
+        return self._format_value(name, self._values[name], placeholder, pathsep)
+
+    @staticmethod
+    def _format_value(name, varvalues, placeholder, pathsep):
+        values = []
+        for v in varvalues:
+            if v == _ENV_VAR_PLACEHOLDER:
+                values.append(placeholder.format(name=name))
+            elif v == _PATHSEP:
+                values.append(pathsep)
+            else:
+                values.append(v)
+        return "".join(values)
+
+    @staticmethod
+    def _list_value(value, separator):
+        if isinstance(value, list):
+            result = []
+            for v in value[:-1]:
+                result.append(v)
+                result.append(separator)
+            result.extend(value[-1:])
+            return result
+        else:
+            return [value]
+
+    def define(self, name, value, separator=" "):
+        value = self._list_value(value, separator)
+        self._values[name] = value
+
+    def define_path(self, name, value):
+        self.define(name, value, _PATHSEP)
+
+    def unset(self, name):
+        """
+        clears the variable, equivalent to a unset or set XXX=
+        """
+        self._values[name] = []
+
+    def append(self, name, value, separator=" "):
+        value = self._list_value(value, separator)
+        self._values[name] = [_ENV_VAR_PLACEHOLDER] + [separator] + value
+
+    def append_path(self, name, value):
+        self.append(name, value, _PATHSEP)
+
+    def prepend(self, name, value, separator=" "):
+        value = self._list_value(value, separator)
+        self._values[name] = value + [separator] + [_ENV_VAR_PLACEHOLDER]
+
+    def prepend_path(self, name, value):
+        self.prepend(name, value, _PATHSEP)
+
+    def save_bat(self, filename, generate_deactivate=True, pathsep=os.pathsep):
+        deactivate = textwrap.dedent("""\
+            echo Capturing current environment in deactivate_{filename}
+            setlocal
+            echo @echo off > "deactivate_{filename}"
+            echo echo Restoring environment >> "deactivate_{filename}"
+            for %%v in ({vars}) do (
+                set foundenvvar=
+                for /f "delims== tokens=1,2" %%a in ('set') do (
+                    if "%%a" == "%%v" (
+                        echo set %%a=%%b>> "deactivate_{filename}"
+                        set foundenvvar=1
+                    )
+                )
+                if not defined foundenvvar (
+                    echo set %%v=>> "deactivate_{filename}"
+                )
+            )
+            endlocal
+
+            """).format(filename=filename, vars=" ".join(self._values.keys()))
+        capture = textwrap.dedent("""\
+            @echo off
+            {deactivate}
+            echo Configuring environment variables
+            """).format(deactivate=deactivate if generate_deactivate else "")
+        result = [capture]
+        for varname, varvalues in self._values.items():
+            value = self._format_value(varname, varvalues, "%{name}%", pathsep)
+            result.append('set {}={}'.format(varname, value))
+
+        content = "\n".join(result)
+        save(filename, content)
+
+    def save_ps1(self, filename, generate_deactivate=True, pathsep=os.pathsep):
+        # FIXME: This is broken and doesnt work
+        deactivate = ""
+        capture = textwrap.dedent("""\
+            {deactivate}
+            """).format(deactivate=deactivate if generate_deactivate else "")
+        result = [capture]
+        for varname, varvalues in self._values.items():
+            value = self._format_value(varname, varvalues, "$env:{name}", pathsep)
+            result.append('Write-Output "Error: whatever message {}"'.format(varname))
+            result.append('$env:{}={}'.format(varname, value))
+
+        content = "\n".join(result)
+        save(filename, content)
+
+    def save_sh(self, filename, pathsep=os.pathsep):
+        capture = textwrap.dedent("""\
+            echo Capturing current environment in deactivate_{filename}
+            echo echo Restoring variables >> deactivate_{filename}
+            for v in {vars}
+            do
+                value=${{!v}}
+                if [ -n "$value" ]
+                then
+                    echo export "$v=$value" >> deactivate_{filename}
+                else
+                    echo unset $v >> deactivate_{filename}
+                fi
+            done
+            echo Configuring environment variables
+            """.format(filename=filename, vars=" ".join(self._values.keys())))
+        result = [capture]
+        for varname, varvalues in self._values.items():
+            value = self._format_value(varname, varvalues, "${name}", pathsep)
+            if value:
+                result.append('export {}="{}"'.format(varname, value))
+            else:
+                result.append('unset {}'.format(varname))
+
+        content = "\n".join(result)
+        save(filename, content)
+
+    def compose(self, other):
+        """
+        :type other: Environment
+        """
+        for k, v in other._values.items():
+            existing = self._values.get(k)
+            if existing is None:
+                self._values[k] = v
+            else:
+                try:
+                    index = v.index(_ENV_VAR_PLACEHOLDER)
+                except ValueError:  # The other doesn't have placeholder, overwrites
+                    self._values[k] = v
+                else:
+                    new_value = v[:]  # do a copy
+                    new_value[index:index + 1] = existing  # replace the placeholder
+                    self._values[k] = new_value
+
+        return self
+
+
+class ProfileEnvironment:
+    def __init__(self):
+        self._environments = OrderedDict()
+
+    def get_env(self, ref):
+        # TODO: Maybe we want to make this lazy, so this is not evaluated for every package
+        result = Environment()
+        for pattern, env in self._environments.items():
+            if pattern is None or fnmatch.fnmatch(str(ref), pattern):
+                env = self._environments[pattern]
+                result = result.compose(env)
+        return result
+
+    def compose(self, other):
+        """
+        :type other: ProfileEnvironment
+        """
+        for pattern, environment in other._environments.items():
+            existing = self._environments.get(pattern)
+            if existing is not None:
+                self._environments[pattern] = existing.compose(environment)
+            else:
+                self._environments[pattern] = environment
+
+    def loads(self, text):
+        for line in text.splitlines():
+            line = line.strip()
+            if not line or line.startswith("#"):
+                continue
+            for op, method in (("+=", "append"), ("=+", "prepend"),
+                               ("=!", "unset"), ("=", "define")):
+                tokens = line.split(op, 1)
+                if len(tokens) != 2:
+                    continue
+                pattern_name, value = tokens
+                pattern_name = pattern_name.split(":", 1)
+                if len(pattern_name) == 2:
+                    pattern, name = pattern_name
+                else:
+                    pattern, name = None, pattern_name[0]
+
+                env = Environment()
+                if method == "unset":
+                    env.unset(name)
+                else:
+                    if value.startswith("(path)"):
+                        value = value[6:]
+                        method = method + "_path"
+                    getattr(env, method)(name, value)
+
+                existing = self._environments.get(pattern)
+                if existing is None:
+                    self._environments[pattern] = env
+                else:
+                    self._environments[pattern] = existing.compose(env)
+                break
+            else:
+                raise ConanException("Bad env defintion: {}".format(line))

conan/tools/env/virtualenv.py

@@ -0,0 +1,98 @@
+import platform
+
+from conan.tools.env import Environment
+from conans.client.graph.graph import CONTEXT_BUILD
+
+
+class VirtualEnv:
+    """ captures the conanfile environment that is defined from its
+    dependencies, and also from profiles
+    """
+
+    def __init__(self, conanfile):
+        self._conanfile = conanfile
+
+    def build_environment(self):
+        """ collects the buildtime information from dependencies. This is the typical use case
+        of build_requires defining information for consumers
+        """
+        # Visit all dependencies
+        deps_env = Environment()
+        # TODO: The visitor of dependencies needs to be implemented correctly
+        # TODO: The environment should probably be composed with direct dependencies first
+        # TODO: in paths, but this is the opposite
+        for dep in self._conanfile.dependencies.all:
+            # environ_info is always "build"
+            dep_env = dep.buildenv_info
+            if dep_env is not None:
+                deps_env.compose(dep_env)
+            if dep.context == CONTEXT_BUILD:
+                runenv = self._runenv_from_cpp_info(dep)
+                deps_env.compose(runenv)
+
+        # The profile environment has precedence, applied last
+        profile_env = self._conanfile.buildenv
+        deps_env.compose(profile_env)
+        return deps_env
+
+    def autorun_environment(self):
+        """ automatically collects the runtime environment from 'cpp_info' from dependencies
+        By default is enabled and will be captured in 'runenv.xxx' but maybe can be disabled
+        by parameter or [conf]
+        """
+        dyn_runenv = Environment()
+        for dep in self._conanfile.dependencies.all:
+            if dep.context == CONTEXT_BUILD:  # Build environment cannot happen in runtime
+                continue
+            env = self._runenv_from_cpp_info(dep)
+            dyn_runenv.compose(env)
+        return dyn_runenv
+
+    @staticmethod
+    def _runenv_from_cpp_info(conanfile_dep):
+        """ return an Environment deducing the runtime information from a cpp_info
+        """
+        dyn_runenv = Environment()
+        cpp_info = conanfile_dep.cpp_info
+        if cpp_info.exes:
+            dyn_runenv.prepend_path("PATH", cpp_info.bin_paths)
+        # If it is a build_require this will be the build-os, otherwise it will be the host-os
+        os_ = conanfile_dep.settings.get_safe("os")
+        if cpp_info.lib_paths:
+            if os_ == "Linux":
+                dyn_runenv.prepend_path("LD_LIBRARY_PATH", cpp_info.lib_paths)
+            elif os_ == "Macos":
+                dyn_runenv.prepend_path("DYLD_LIBRARY_PATH", cpp_info.lib_paths)
+        if cpp_info.framework_paths:
+            dyn_runenv.prepend_path("DYLD_FRAMEWORK_PATH", cpp_info.framework_paths)
+        return dyn_runenv
+
+    def run_environment(self):
+        """ collects the runtime information from dependencies. For normal libraries should be
+        very occasional
+        """
+        # Visit all dependencies
+        deps_env = Environment()
+        for dep in self._conanfile.dependencies.all:
+            # run_environ_info is always "host"
+            dep_env = dep.runenv_info
+            if dep_env is not None:
+                deps_env.compose(dep_env)
+
+        autorun = self.autorun_environment()
+        deps_env.compose(autorun)
+        # FIXME: Missing profile info
+        result = deps_env
+        return result
+
+    def generate(self):
+        build_env = self.build_environment()
+        run_env = self.run_environment()
+        # FIXME: Use settings, not platform Not always defined :(
+        # os_ = self._conanfile.settings_build.get_safe("os")
+        if platform.system() == "Windows":
+            build_env.save_bat("buildenv.bat")
+            run_env.save_bat("runenv.bat")
+        else:
+            build_env.save_sh("buildenv.sh")
+            run_env.save_sh("runenv.sh")

conans/client/generators/__init__.py

@@ -66,7 +66,8 @@ def __init__(self):
                             "deploy": DeployGenerator,
                             "markdown": MarkdownGenerator}
         self._new_generators = ["CMakeToolchain", "CMakeDeps", "MakeToolchain", "MSBuildToolchain",
-                                "MesonToolchain", "MSBuildDeps", "QbsToolchain", "msbuild"]
+                                "MesonToolchain", "MSBuildDeps", "QbsToolchain", "msbuild",
+                                "VirtualEnv"]
 
     def add(self, name, generator_class, custom=False):
         if name not in self._generators or custom:
@@ -110,6 +111,9 @@ def _new_generator(self, generator_name, output):
         elif generator_name == "QbsToolchain":
             from conan.tools.qbs.qbstoolchain import QbsToolchain
             return QbsToolchain
+        elif generator_name == "VirtualEnv":
+            from conan.tools.env.virtualenv import VirtualEnv
+            return VirtualEnv
         else:
             raise ConanException("Internal Conan error: Generator '{}' "
                                  "not commplete".format(generator_name))
@@ -195,5 +199,3 @@ def write_toolchain(conanfile, path, output):
         with chdir(path):
             with conanfile_exception_formatter(str(conanfile), "generate"):
                 conanfile.generate()
-
-        # TODO: Lets discuss what to do with the environment

conans/client/graph/graph_builder.py

@@ -53,6 +53,7 @@ def load_graph(self, root_node, check_updates, update, remotes, profile_host, pr
         initial = graph_lock.initial_counter if graph_lock else None
         dep_graph = DepsGraph(initial_node_id=initial)
         # compute the conanfile entry point for this dependency graph
+        root_node.conanfile.context = CONTEXT_HOST  # FIXME: Is this always true?
         root_node.public_closure.add(root_node)
         root_node.public_deps.add(root_node)
         root_node.transitive_closure[root_node.name] = root_node
@@ -205,7 +206,8 @@ def _expand_require(self, require, node, graph, check_updates, update, remotes,
                                              remotes, profile_host, profile_build, graph_lock,
                                              context_switch=context_switch,
                                              populate_settings_target=populate_settings_target)
-
+            new_node.conanfile._conan_context = context
+            node.conanfile.dependencies.add(new_node.conanfile)
             # The closure of a new node starts with just itself
             new_node.public_closure.add(new_node)
             new_node.transitive_closure[new_node.name] = new_node
@@ -237,6 +239,7 @@ def _expand_require(self, require, node, graph, check_updates, update, remotes,
                     node.transitive_closure[name] = n
 
         else:  # a public node already exist with this name
+            node.conanfile.dependencies.add(previous.conanfile)
             self._resolve_cached_alias([require], graph)
             # As we are closing a diamond, there can be conflicts. This will raise if conflicts
             conflict = self._conflicting_references(previous, require.ref, node.ref)