fix(python): restore CONDA_DEFAULT_ENV

resolves #360

docs/docs/segment-python.md

@@ -27,6 +27,8 @@ Supports conda, virtualenv and pyenv.
 ## Properties
 
 - display_virtual_env: `boolean` - show the name of the virtualenv or not - defaults to `true`
+- display_default_env: `boolean` - show the name of the virtualenv when it's default (`system`, `base`)
+or not - defaults to `true`
 - display_version: `boolean` - display the python version - defaults to `true`
 - missing_command_text: `string` - text to display when the command is missing - defaults to empty
 - display_mode: `string` - determines when the segment is displayed

src/segment_python.go

@@ -10,6 +10,8 @@ type python struct {
 const (
 	// DisplayVirtualEnv shows or hides the virtual env
 	DisplayVirtualEnv Property = "display_virtual_env"
+	// DisplayDefaultEnv shows or hides the default env names (system/base)
+	DisplayDefaultEnv Property = "display_default_env"
 )
 
 func (p *python) string() string {
@@ -44,13 +46,15 @@ func (p *python) loadContext() {
 	venvVars := []string{
 		"VIRTUAL_ENV",
 		"CONDA_ENV_PATH",
+		"CONDA_DEFAULT_ENV",
 		"PYENV_VERSION",
 	}
 	var venv string
 	for _, venvVar := range venvVars {
 		venv = p.language.env.getenv(venvVar)
-		if venv != "" {
+		name := base(venv, p.language.env)
-			p.venvName = base(venv, p.language.env)
+		if p.canUseVenvName(name) {
+			p.venvName = name
 			break
 		}
 	}
@@ -59,3 +63,19 @@ func (p *python) loadContext() {
 func (p *python) inContext() bool {
 	return p.venvName != ""
 }
+
+func (p *python) canUseVenvName(name string) bool {
+	if name == "" || name == "." {
+		return false
+	}
+	if p.language.props.getBool(DisplayDefaultEnv, true) {
+		return true
+	}
+	invalidNames := [2]string{"system", "base"}
+	for _, a := range invalidNames {
+		if a == name {
+			return false
+		}
+	}
+	return true
+}

src/segment_python_test.go

@@ -6,87 +6,68 @@ import (
 	"github.com/alecthomas/assert"
 )
 
-type pythonArgs struct {
+func TestPythonVirtualEnv(t *testing.T) {
-	virtualEnvName string
+	cases := []struct {
-	condaEnvName   string
+		Expected            string
-	pyEnvName      string
+		VirtualEnvName      string
-	displayVersion bool
+		CondaEnvName        string
-}
+		CondaDefaultEnvName string
-
+		PyEnvName           string
-func bootStrapPythonTest(args *pythonArgs) *python {
+		DisplayVersion      bool
-	env := new(MockedEnvironment)
+		DisplayDefaultEnv   bool
-	env.On("hasCommand", "python").Return(true)
+	}{
-	env.On("runCommand", "python", []string{"--version"}).Return("Python 3.8.4", nil)
+		{Expected: "VENV", VirtualEnvName: "VENV"},
-	env.On("hasFiles", "*.py").Return(true)
+		{Expected: "CONDA", CondaEnvName: "CONDA"},
-	env.On("getenv", "VIRTUAL_ENV").Return(args.virtualEnvName)
+		{Expected: "CONDA", CondaDefaultEnvName: "CONDA"},
-	env.On("getenv", "CONDA_ENV_PATH").Return(args.condaEnvName)
+		{Expected: "", CondaDefaultEnvName: "base"},
-	env.On("getenv", "PYENV_VERSION").Return(args.pyEnvName)
+		{Expected: "base", CondaDefaultEnvName: "base", DisplayDefaultEnv: true},
-	env.On("getPathSeperator", nil).Return("")
+		{Expected: "PYENV", PyEnvName: "PYENV"},
-	props := &properties{
+		{Expected: "PYENV 3.8.4", PyEnvName: "PYENV", DisplayVersion: true},
-		values: map[Property]interface{}{
-			DisplayVersion:    args.displayVersion,
-			DisplayVirtualEnv: true,
-		},
 	}
-	python := &python{}
-	python.init(props, env)
-	return python
-}
 
-func TestPythonVertualEnv(t *testing.T) {
+	for _, tc := range cases {
-	expected := "VENV"
+		env := new(MockedEnvironment)
-	args := &pythonArgs{
+		env.On("hasCommand", "python").Return(true)
-		virtualEnvName: expected,
+		env.On("runCommand", "python", []string{"--version"}).Return("Python 3.8.4", nil)
+		env.On("hasFiles", "*.py").Return(true)
+		env.On("getenv", "VIRTUAL_ENV").Return(tc.VirtualEnvName)
+		env.On("getenv", "CONDA_ENV_PATH").Return(tc.CondaEnvName)
+		env.On("getenv", "CONDA_DEFAULT_ENV").Return(tc.CondaDefaultEnvName)
+		env.On("getenv", "PYENV_VERSION").Return(tc.PyEnvName)
+		env.On("getPathSeperator", nil).Return("")
+		props := &properties{
+			values: map[Property]interface{}{
+				DisplayVersion:    tc.DisplayVersion,
+				DisplayVirtualEnv: true,
+				DisplayDefaultEnv: tc.DisplayDefaultEnv,
+			},
+		}
+		python := &python{}
+		python.init(props, env)
+		assert.True(t, python.enabled())
+		assert.Equal(t, tc.Expected, python.string())
 	}
-	python := bootStrapPythonTest(args)
-	assert.True(t, python.enabled())
-	assert.Equal(t, expected, python.string())
-}
-
-func TestPythonCondaEnv(t *testing.T) {
-	expected := "CONDA"
-	args := &pythonArgs{
-		condaEnvName: expected,
-	}
-	python := bootStrapPythonTest(args)
-	assert.True(t, python.enabled())
-	assert.Equal(t, expected, python.string())
-}
-
-func TestPythonPyEnv(t *testing.T) {
-	expected := "PYENV"
-	args := &pythonArgs{
-		pyEnvName: expected,
-	}
-	python := bootStrapPythonTest(args)
-	assert.True(t, python.enabled())
-	assert.Equal(t, expected, python.string())
-}
-
-func TestPythonPyEnvWithVersion(t *testing.T) {
-	expected := "PYENV 3.8.4"
-	args := &pythonArgs{
-		pyEnvName:      "PYENV",
-		displayVersion: true,
-	}
-	python := bootStrapPythonTest(args)
-	assert.True(t, python.enabled())
-	assert.Equal(t, expected, python.string())
-	assert.Equal(t, "3.8.4", python.language.version)
 }
 
 func TestPythonPythonInContext(t *testing.T) {
-	args := &pythonArgs{
+	cases := []struct {
-		pyEnvName:      "PYENV",
+		Expected       bool
-		displayVersion: true,
+		VirtualEnvName string
+	}{
+		{Expected: true, VirtualEnvName: "VENV"},
+		{Expected: false, VirtualEnvName: ""},
 	}
-	python := bootStrapPythonTest(args)
-	python.loadContext()
-	assert.True(t, python.inContext())
-}
 
-func TestPythonPythonNotInContext(t *testing.T) {
+	for _, tc := range cases {
-	python := bootStrapPythonTest(&pythonArgs{})
+		env := new(MockedEnvironment)
-	python.loadContext()
+		env.On("getPathSeperator", nil).Return("")
-	assert.False(t, python.inContext())
+		env.On("getenv", "VIRTUAL_ENV").Return(tc.VirtualEnvName)
+		env.On("getenv", "CONDA_ENV_PATH").Return("")
+		env.On("getenv", "CONDA_DEFAULT_ENV").Return("")
+		env.On("getenv", "PYENV_VERSION").Return("")
+		python := &python{}
+		python.init(nil, env)
+		python.loadContext()
+		assert.Equal(t, tc.Expected, python.inContext())
+	}
 }