Ytdyklly

I have been working on several projects, and they require different environment variables (e.g., PATH for different versions of clang executables, PYTHONPATH for several external modules). Whenever I work on one project, I have to modify these environment variables myself (e.g., change .zshrc/.bashrc and source it); and I sometimes forget and make mistakes.

Is there a way/project that helps do this automatically, similar to what virtualenv does in Python?

You can source any file you like, it doesn't have to be .zshrc. You could make an env-setup script for each different project, and keep it in the project directory.

If you want to be able to start new shells and have them load the env settings, you have a couple options:

• Always start your shells in the project directory, and have your .zshrc [[ -e ./PROJECT-ENV.sh ]] && source ./PROJECT-ENV.sh (which you keep there). DANGEROUS: starting a new shell in a directory with hostile contents runs whatever code is in the file you source.


• 
  .zshrc: source ~/current-project.sh. update current project with ln -sf "$PWD/THIS-PROJECT-ENV.sh ~/current-project.sh
  

If only a few commands for each project need the env vars set, you could make wrapper scripts for them that set the variables, and then leave your shell rc file untouched.

Another idea: you could hack something into PROMPT_COMMAND, which runs before every prompt is displayed. Or hook cd/pushd/popd by writing shell functions with those names which check/set env vars and then run builtin cd.

Yuch, too much maintenance and too much individual stuff.

I'd recommend putting most of the effort into having appropriately scoped names that are appropriate for the platform so you can just have all of them all of the time. PYTHONPATH is a good example... you're unlikely to want to repurpose it for a Ruby project... You can group and mark the group with comments in the .bashrc to ease maintenance.

It is not always possible to do that, i.e.. when there is conflict (plus it requires editing and not using discrete files) and sometimes you will need a framework specific setup file. One approach to that is to have aliases setup to run them, e.g.

e.g.

alias pp='. ~/pp.setup' # For using Python

alias rb='. /rb.setup'  # For using Ruby

You could also create a function, something like 'switcher' that uses/sets a variable and just switches using a parameter passed in, or just toggles to what isn't current.

There are management tools such as modules, that allow dynamic modification of a user's environment... though this one is no longer developed; last version is from 2012

Example:

$ module load gcc/3.1.1

$ which gcc

/usr/local/gcc/3.1.1/linux/bin/gcc

Inspired by @Peter Cordes and @Michael Durrant's answers, I came up with a limited and lightweight solution for my special case.

Firstly let me re-illustrate my real issues.

I need to use different llvm related executables (clang, llvm-config, etc) that are under project local directories, and I need to use 1 default version for general purpose (compiling, etc). I also need to need to use different python modules (llvm python bindings) inside different local directories.

Since all my llvm related projects are built with similar directory structures, I specify the llvm version related environment variable (MY_LLVM_VERSION) and add the directories to PATH and PYTHONPATH. I used a function named _my_llvm_version that customize the variable interactively. As functions only have effects inside it, I use aliases to do the real source work. Then let MY_LLVM_VERSION defaults to my commonly used one (git). These are all inside ~/.zlocal that will be sourced for an interactive zsh. (Full file is here). By sourcing ~/.zlocal, I'm able to change PATH and PYTHONPATH according to MY_LLVM_VERSION.

function _my_llvm_version() {

    available=("3.3" "3.4" "3.5" "git")

    USAGE="my_llvm_version 3.3|3.4|3.5|git"

    if [ $# -ne 1 ] || ! (( ${available[(I)${1}]} )); then

      echo "usage: $USAGE"

    fi

    MY_LLVM_VERSION="$1"

}

alias my_ll33='_my_llvm_version 3.3;source ~/.zlocal'

alias my_ll34='_my_llvm_version 3.4;source ~/.zlocal'

alias my_ll35='_my_llvm_version 3.5;source ~/.zlocal'

alias my_llgit='_my_llvm_version git;source ~/.zlocal'

: ${MY_LLVM_VERSION:=git}

I think it should be more maintainable and do not invoke a child shell. It should be useful to add llvm version to PS1 area, but currently I do not need that.

Of course, this solution is not general and not a real solution to my original question.

You can use direnv to load environment variables on directory change. From its homepage:

direnv is an environment switcher for the shell. It knows how to hook into bash, zsh, tcsh, fish shell and elvish to load or unload environment variables depending on the current directory. This allows project-specific environment variables without cluttering the ~/.profile file.

I am using it with the xonsh shell (via a small additional plugin) and it works excellent.