kubens add a short-circuit to bypass API call for tests

Signed-off-by: Ahmet Alp Balkan <ahmetb@google.com>
ns list: increase page size to 500
2026-02-25 09:32:25 +00:00 · 2020-04-29 12:52:08 -07:00 · 2020-04-29 12:43:07 -07:00 · 2020-04-29 12:35:27 -07:00 · 2020-04-29 12:16:26 -07:00 · 2020-04-29 12:11:59 -07:00
53 changed files with 2913 additions and 15 deletions
--- a/cmd/kubectx/current.go
+++ b/cmd/kubectx/current.go
@@ -0,0 +1,29 @@
+package main
+
+import (
+	"fmt"
+	"io"
+
+	"github.com/pkg/errors"
+
+	"github.com/ahmetb/kubectx/internal/cmdutil"
+	"github.com/ahmetb/kubectx/internal/kubeconfig"
+)
+
+// CurrentOp prints the current context
+type CurrentOp struct{}
+
+func (_op CurrentOp) Run(stdout, _ io.Writer) error {
+	kc := new(kubeconfig.Kubeconfig).WithLoader(cmdutil.DefaultLoader)
+	defer kc.Close()
+	if err := kc.Parse(); err != nil {
+		return errors.Wrap(err, "kubeconfig error")
+	}
+
+	v := kc.GetCurrentContext()
+	if v == "" {
+		return errors.New("current-context is not set")
+	}
+	_, err := fmt.Fprintln(stdout, v)
+	return errors.Wrap(err, "write error")
+}
--- a/cmd/kubectx/delete.go
+++ b/cmd/kubectx/delete.go
@@ -0,0 +1,63 @@
+package main
+
+import (
+	"io"
+
+	"github.com/pkg/errors"
+
+	"github.com/ahmetb/kubectx/internal/cmdutil"
+	"github.com/ahmetb/kubectx/internal/kubeconfig"
+	"github.com/ahmetb/kubectx/internal/printer"
+)
+
+// DeleteOp indicates intention to delete contexts.
+type DeleteOp struct {
+	Contexts []string // NAME or '.' to indicate current-context.
+}
+
+// deleteContexts deletes context entries one by one.
+func (op DeleteOp) Run(_, stderr io.Writer) error {
+	for _, ctx := range op.Contexts {
+		// TODO inefficency here. we open/write/close the same file many times.
+		deletedName, wasActiveContext, err := deleteContext(ctx)
+		if err != nil {
+			return errors.Wrapf(err, "error deleting context %q", deletedName)
+		}
+		if wasActiveContext {
+			printer.Warning(stderr, "You deleted the current context. Use \"%s\" to select a new context.",
+				selfName())
+		}
+
+		printer.Success(stderr, `Deleted context %s.`, printer.SuccessColor.Sprint(deletedName))
+	}
+	return nil
+}
+
+// deleteContext deletes a context entry by NAME or current-context
+// indicated by ".".
+func deleteContext(name string) (deleteName string, wasActiveContext bool, err error) {
+	kc := new(kubeconfig.Kubeconfig).WithLoader(cmdutil.DefaultLoader)
+	defer kc.Close()
+	if err := kc.Parse(); err != nil {
+		return deleteName, false, errors.Wrap(err, "kubeconfig error")
+	}
+
+	cur := kc.GetCurrentContext()
+	// resolve "." to a real name
+	if name == "." {
+		if cur == "" {
+			return deleteName, false, errors.New("can't use '.' as the no active context is set")
+		}
+		wasActiveContext = true
+		name = cur
+	}
+
+	if !kc.ContextExists(name) {
+		return name, false, errors.New("context does not exist")
+	}
+
+	if err := kc.DeleteContextEntry(name); err != nil {
+		return name, false, errors.Wrap(err, "failed to modify yaml doc")
+	}
+	return name, wasActiveContext, errors.Wrap(kc.Save(), "failed to save modified kubeconfig file")
+}
--- a/cmd/kubectx/env.go
+++ b/cmd/kubectx/env.go
@@ -0,0 +1 @@
+package main
--- a/cmd/kubectx/flags.go
+++ b/cmd/kubectx/flags.go
@@ -0,0 +1,58 @@
+package main
+
+import (
+	"fmt"
+	"io"
+	"os"
+	"strings"
+
+	"github.com/ahmetb/kubectx/internal/cmdutil"
+)
+
+// UnsupportedOp indicates an unsupported flag.
+type UnsupportedOp struct{ Err error }
+
+func (op UnsupportedOp) Run(_, _ io.Writer) error {
+	return op.Err
+}
+
+// parseArgs looks at flags (excl. executable name, i.e. argv[0])
+// and decides which operation should be taken.
+func parseArgs(argv []string) Op {
+	if len(argv) == 0 {
+		if cmdutil.IsInteractiveMode(os.Stdout) {
+			return InteractiveSwitchOp{SelfCmd: os.Args[0]}
+		}
+		return ListOp{}
+	}
+
+	if argv[0] == "-d" {
+		if len(argv) == 1 {
+			return UnsupportedOp{Err: fmt.Errorf("'-d' needs arguments")}
+		}
+		return DeleteOp{Contexts: argv[1:]}
+	}
+
+	if len(argv) == 1 {
+		v := argv[0]
+		if v == "--help" || v == "-h" {
+			return HelpOp{}
+		}
+		if v == "--current" || v == "-c" {
+			return CurrentOp{}
+		}
+		if v == "--unset" || v == "-u" {
+			return UnsetOp{}
+		}
+
+		if new, old, ok := parseRenameSyntax(v); ok {
+			return RenameOp{New: new, Old: old}
+		}
+
+		if strings.HasPrefix(v, "-") && v != "-" {
+			return UnsupportedOp{Err: fmt.Errorf("unsupported option '%s'", v)}
+		}
+		return SwitchOp{Target: argv[0]}
+	}
+	return UnsupportedOp{Err: fmt.Errorf("too many arguments")}
+}
--- a/cmd/kubectx/flags_test.go
+++ b/cmd/kubectx/flags_test.go
@@ -0,0 +1,84 @@
+package main
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/google/go-cmp/cmp"
+)
+
+func Test_parseArgs_new(t *testing.T) {
+	tests := []struct {
+		name string
+		args []string
+		want Op
+	}{
+		{name: "nil Args",
+			args: nil,
+			want: ListOp{}},
+		{name: "empty Args",
+			args: []string{},
+			want: ListOp{}},
+		{name: "help shorthand",
+			args: []string{"-h"},
+			want: HelpOp{}},
+		{name: "help long form",
+			args: []string{"--help"},
+			want: HelpOp{}},
+		{name: "current shorthand",
+			args: []string{"-c"},
+			want: CurrentOp{}},
+		{name: "current long form",
+			args: []string{"--current"},
+			want: CurrentOp{}},
+		{name: "unset shorthand",
+			args: []string{"-u"},
+			want: UnsetOp{}},
+		{name: "unset long form",
+			args: []string{"--unset"},
+			want: UnsetOp{}},
+		{name: "switch by name",
+			args: []string{"foo"},
+			want: SwitchOp{Target: "foo"}},
+		{name: "switch by swap",
+			args: []string{"-"},
+			want: SwitchOp{Target: "-"}},
+		{name: "delete - without contexts",
+			args: []string{"-d"},
+			want: UnsupportedOp{fmt.Errorf("'-d' needs arguments")}},
+		{name: "delete - current context",
+			args: []string{"-d", "."},
+			want: DeleteOp{[]string{"."}}},
+		{name: "delete - multiple contexts",
+			args: []string{"-d", ".", "a", "b"},
+			want: DeleteOp{[]string{".", "a", "b"}}},
+		{name: "rename context",
+			args: []string{"a=b"},
+			want: RenameOp{"a", "b"}},
+		{name: "rename context with old=current",
+			args: []string{"a=."},
+			want: RenameOp{"a", "."}},
+		{name: "unrecognized flag",
+			args: []string{"-x"},
+			want: UnsupportedOp{Err: fmt.Errorf("unsupported option '-x'")}},
+		{name: "too many args",
+			args: []string{"a", "b", "c"},
+			want: UnsupportedOp{Err: fmt.Errorf("too many arguments")}},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := parseArgs(tt.args)
+
+			var opts cmp.Options
+			if _, ok := tt.want.(UnsupportedOp); ok {
+				opts = append(opts, cmp.Comparer(func(x, y UnsupportedOp) bool {
+					return (x.Err == nil && y.Err == nil) || (x.Err.Error() == y.Err.Error())
+				}))
+			}
+
+			if diff := cmp.Diff(got, tt.want, opts...); diff != "" {
+				t.Errorf("parseArgs(%#v) diff: %s", tt.args, diff)
+			}
+		})
+	}
+}
--- a/cmd/kubectx/fzf.go
+++ b/cmd/kubectx/fzf.go
@@ -0,0 +1,59 @@
+package main
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+	"os"
+	"os/exec"
+	"strings"
+
+	"github.com/pkg/errors"
+
+	"github.com/ahmetb/kubectx/internal/cmdutil"
+	"github.com/ahmetb/kubectx/internal/env"
+	"github.com/ahmetb/kubectx/internal/kubeconfig"
+	"github.com/ahmetb/kubectx/internal/printer"
+)
+
+type InteractiveSwitchOp struct {
+	SelfCmd string
+}
+
+func (op InteractiveSwitchOp) Run(_, stderr io.Writer) error {
+	// parse kubeconfig just to see if it can be loaded
+	kc := new(kubeconfig.Kubeconfig).WithLoader(cmdutil.DefaultLoader)
+	if err := kc.Parse(); err != nil {
+		if cmdutil.IsNotFoundErr(err) {
+			printer.Warning(stderr, "kubeconfig file not found")
+			return nil
+		}
+		return errors.Wrap(err, "kubeconfig error")
+	}
+	kc.Close()
+
+	cmd := exec.Command("fzf", "--ansi", "--no-preview")
+	var out bytes.Buffer
+	cmd.Stdin = os.Stdin
+	cmd.Stderr = stderr
+	cmd.Stdout = &out
+
+	cmd.Env = append(os.Environ(),
+		fmt.Sprintf("FZF_DEFAULT_COMMAND=%s", op.SelfCmd),
+		fmt.Sprintf("%s=1", env.EnvForceColor))
+	if err := cmd.Run(); err != nil {
+		if _, ok := err.(*exec.ExitError); !ok {
+			return err
+		}
+	}
+	choice := strings.TrimSpace(out.String())
+	if choice == "" {
+		return errors.New("you did not choose any of the options")
+	}
+	name, err := switchContext(choice)
+	if err != nil {
+		return errors.Wrap(err, "failed to switch context")
+	}
+	printer.Success(stderr, "Switched to context %s.", printer.SuccessColor.Sprint(name))
+	return nil
+}
--- a/cmd/kubectx/help.go
+++ b/cmd/kubectx/help.go
@@ -0,0 +1,48 @@
+package main
+
+import (
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/pkg/errors"
+)
+
+// HelpOp describes printing help.
+type HelpOp struct{}
+
+func (_ HelpOp) Run(stdout, _ io.Writer) error {
+	return printUsage(stdout)
+}
+
+func printUsage(out io.Writer) error {
+	help := `USAGE:
+  %PROG%                       : list the contexts
+  %PROG% <NAME>                : switch to context <NAME>
+  %PROG% -                     : switch to the previous context
+  %PROG% -c, --current         : show the current context name
+  %PROG% <NEW_NAME>=<NAME>     : rename context <NAME> to <NEW_NAME>
+  %PROG% <NEW_NAME>=.          : rename current-context to <NEW_NAME>
+  %PROG% -u, --unset           : unset the current context  
+  %PROG% -d <NAME> [<NAME...>] : delete context <NAME> ('.' for current-context)
+  %SPAC%                         (this command won't delete the user/cluster entry
+  %SPAC%                          referenced by the context entry)
+  %PROG% -h,--help             : show this message`
+	help = strings.ReplaceAll(help, "%PROG%", selfName())
+	help = strings.ReplaceAll(help, "%SPAC%", strings.Repeat(" ", len(selfName())))
+
+	_, err := fmt.Fprintf(out, "%s\n", help)
+	return errors.Wrap(err, "write error")
+}
+
+// selfName guesses how the user invoked the program.
+func selfName() string {
+	me := filepath.Base(os.Args[0])
+	pluginPrefix := "kubectl-"
+	if strings.HasPrefix(me, pluginPrefix) {
+		return "kubectl " + strings.TrimPrefix(me, pluginPrefix)
+	}
+	return "kubectx"
+}
--- a/cmd/kubectx/help_test.go
+++ b/cmd/kubectx/help_test.go
@@ -0,0 +1,23 @@
+package main
+
+import (
+	"bytes"
+	"strings"
+	"testing"
+)
+
+func TestPrintHelp(t *testing.T) {
+	var buf bytes.Buffer
+	if err := (&HelpOp{}).Run(&buf, &buf); err != nil {
+		t.Fatal(err)
+	}
+
+	out := buf.String()
+	if !strings.Contains(out, "USAGE:") {
+		t.Errorf("help string doesn't contain USAGE: ; output=%q", out)
+	}
+
+	if !strings.HasSuffix(out, "\n") {
+		t.Errorf("does not end with New line; output=%q", out)
+	}
+}
--- a/cmd/kubectx/list.go
+++ b/cmd/kubectx/list.go
@@ -0,0 +1,41 @@
+package main
+
+import (
+	"fmt"
+	"io"
+
+	"facette.io/natsort"
+	"github.com/pkg/errors"
+
+	"github.com/ahmetb/kubectx/internal/cmdutil"
+	"github.com/ahmetb/kubectx/internal/kubeconfig"
+	"github.com/ahmetb/kubectx/internal/printer"
+)
+
+// ListOp describes listing contexts.
+type ListOp struct{}
+
+func (_ ListOp) Run(stdout, stderr io.Writer) error {
+	kc := new(kubeconfig.Kubeconfig).WithLoader(cmdutil.DefaultLoader)
+	defer kc.Close()
+	if err := kc.Parse(); err != nil {
+		if cmdutil.IsNotFoundErr(err) {
+			printer.Warning(stderr, "kubeconfig file not found")
+			return nil
+		}
+		return errors.Wrap(err, "kubeconfig error")
+	}
+
+	ctxs := kc.ContextNames()
+	natsort.Sort(ctxs)
+
+	cur := kc.GetCurrentContext()
+	for _, c := range ctxs {
+		s := c
+		if c == cur {
+			s = printer.ActiveItemColor.Sprint(c)
+		}
+		fmt.Fprintf(stdout, "%s\n", s)
+	}
+	return nil
+}
--- a/cmd/kubectx/main.go
+++ b/cmd/kubectx/main.go
@@ -0,0 +1,30 @@
+package main
+
+import (
+	"fmt"
+	"io"
+	"os"
+
+	"github.com/ahmetb/kubectx/internal/cmdutil"
+	"github.com/ahmetb/kubectx/internal/env"
+	"github.com/ahmetb/kubectx/internal/printer"
+)
+
+type Op interface {
+	Run(stdout, stderr io.Writer) error
+}
+
+func main() {
+	cmdutil.PrintDeprecatedEnvWarnings(os.Stderr, os.Environ())
+
+	op := parseArgs(os.Args[1:])
+	if err := op.Run(os.Stdout, os.Stderr); err != nil {
+		printer.Error(os.Stderr, err.Error())
+
+		if _, ok := os.LookupEnv(env.EnvDebug); ok {
+			// print stack trace in verbose mode
+			fmt.Fprintf(os.Stderr, "[DEBUG] error: %+v\n", err)
+		}
+		defer os.Exit(1)
+	}
+}
--- a/cmd/kubectx/rename.go
+++ b/cmd/kubectx/rename.go
@@ -0,0 +1,75 @@
+package main
+
+import (
+	"io"
+	"strings"
+
+	"github.com/pkg/errors"
+
+	"github.com/ahmetb/kubectx/internal/cmdutil"
+	"github.com/ahmetb/kubectx/internal/kubeconfig"
+	"github.com/ahmetb/kubectx/internal/printer"
+)
+
+// RenameOp indicates intention to rename contexts.
+type RenameOp struct {
+	New string // NAME of New context
+	Old string // NAME of Old context (or '.' for current-context)
+}
+
+// parseRenameSyntax parses A=B form into [A,B] and returns
+// whether it is parsed correctly.
+func parseRenameSyntax(v string) (string, string, bool) {
+	s := strings.Split(v, "=")
+	if len(s) != 2 {
+		return "", "", false
+	}
+	new, old := s[0], s[1]
+	if new == "" || old == "" {
+		return "", "", false
+	}
+	return new, old, true
+}
+
+// rename changes the old (NAME or '.' for current-context)
+// to the "new" value. If the old refers to the current-context,
+// current-context preference is also updated.
+func (op RenameOp) Run(_, stderr io.Writer) error {
+	kc := new(kubeconfig.Kubeconfig).WithLoader(cmdutil.DefaultLoader)
+	defer kc.Close()
+	if err := kc.Parse(); err != nil {
+		return errors.Wrap(err, "kubeconfig error")
+	}
+
+	cur := kc.GetCurrentContext()
+	if op.Old == "." {
+		op.Old = cur
+	}
+
+	if !kc.ContextExists(op.Old) {
+		return errors.Errorf("context %q not found, can't rename it", op.Old)
+	}
+
+	if kc.ContextExists(op.New) {
+		printer.Warning(stderr, "context %q exists, overwriting it.", op.New)
+		if err := kc.DeleteContextEntry(op.New); err != nil {
+			return errors.Wrap(err, "failed to delete new context to overwrite it")
+		}
+	}
+
+	if err := kc.ModifyContextName(op.Old, op.New); err != nil {
+		return errors.Wrap(err, "failed to change context name")
+	}
+	if op.Old == cur {
+		if err := kc.ModifyCurrentContext(op.New); err != nil {
+			return errors.Wrap(err, "failed to set current-context to new name")
+		}
+	}
+	if err := kc.Save(); err != nil {
+		return errors.Wrap(err, "failed to save modified kubeconfig")
+	}
+	printer.Success(stderr, "Context %s renamed to %s.",
+		printer.SuccessColor.Sprint(op.Old),
+		printer.SuccessColor.Sprint(op.New))
+	return nil
+}
--- a/cmd/kubectx/rename_test.go
+++ b/cmd/kubectx/rename_test.go
@@ -0,0 +1,69 @@
+package main
+
+import (
+	"testing"
+
+	"github.com/google/go-cmp/cmp"
+)
+
+func Test_parseRenameSyntax(t *testing.T) {
+
+	type out struct {
+		New string
+		Old string
+		OK  bool
+	}
+	tests := []struct {
+		name string
+		in   string
+		want out
+	}{
+		{
+			name: "no equals sign",
+			in:   "foo",
+			want: out{OK: false},
+		},
+		{
+			name: "no left side",
+			in:   "=a",
+			want: out{OK: false},
+		},
+		{
+			name: "no right side",
+			in:   "a=",
+			want: out{OK: false},
+		},
+		{
+			name: "correct format",
+			in:   "a=b",
+			want: out{
+				New: "a",
+				Old: "b",
+				OK:  true,
+			},
+		},
+		{
+			name: "correct format with current context",
+			in:   "NEW_NAME=.",
+			want: out{
+				New: "NEW_NAME",
+				Old: ".",
+				OK:  true,
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			new, old, ok := parseRenameSyntax(tt.in)
+			got := out{
+				New: new,
+				Old: old,
+				OK:  ok,
+			}
+			diff := cmp.Diff(tt.want, got)
+			if diff != "" {
+				t.Errorf("parseRenameSyntax() diff=%s", diff)
+			}
+		})
+	}
+}
--- a/cmd/kubectx/state.go
+++ b/cmd/kubectx/state.go
@@ -0,0 +1,39 @@
+package main
+
+import (
+	"io/ioutil"
+	"os"
+	"path/filepath"
+
+	"github.com/pkg/errors"
+
+	"github.com/ahmetb/kubectx/internal/cmdutil"
+)
+
+func kubectxPrevCtxFile() (string, error) {
+	home := cmdutil.HomeDir()
+	if home == "" {
+		return "", errors.New("HOME or USERPROFILE environment variable not set")
+	}
+	return filepath.Join(home, ".kube", "kubectx"), nil
+}
+
+// readLastContext returns the saved previous context
+// if the state file exists, otherwise returns "".
+func readLastContext(path string) (string, error) {
+	b, err := ioutil.ReadFile(path)
+	if os.IsNotExist(err) {
+		return "", nil
+	}
+	return string(b), err
+}
+
+// writeLastContext saves the specified value to the state file.
+// It creates missing parent directories.
+func writeLastContext(path, value string) error {
+	dir := filepath.Dir(path)
+	if err := os.MkdirAll(dir, 0755); err != nil {
+		return errors.Wrap(err, "failed to create parent directories")
+	}
+	return ioutil.WriteFile(path, []byte(value), 0644)
+}
--- a/cmd/kubectx/state_test.go
+++ b/cmd/kubectx/state_test.go
@@ -0,0 +1,91 @@
+package main
+
+import (
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/ahmetb/kubectx/internal/testutil"
+)
+
+func Test_readLastContext_nonExistingFile(t *testing.T) {
+	s, err := readLastContext(filepath.FromSlash("/non/existing/file"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if s != "" {
+		t.Fatalf("expected empty string; got=%q", s)
+	}
+}
+
+func Test_readLastContext(t *testing.T) {
+	path, cleanup := testutil.TempFile(t, "foo")
+	defer cleanup()
+
+	s, err := readLastContext(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if expected := "foo"; s != expected {
+		t.Fatalf("expected=%q; got=%q", expected, s)
+	}
+}
+
+func Test_writeLastContext_err(t *testing.T) {
+	path := filepath.Join(os.DevNull, "foo", "bar")
+	err := writeLastContext(path, "foo")
+	if err == nil {
+		t.Fatal("got empty error")
+	}
+}
+
+func Test_writeLastContext(t *testing.T) {
+	dir, err := ioutil.TempDir(os.TempDir(), "state-file-test")
+	if err != nil {
+		t.Fatal(err)
+	}
+	path := filepath.Join(dir, "foo", "bar")
+
+	if err := writeLastContext(path, "ctx1"); err != nil {
+		t.Fatal(err)
+	}
+
+	v, err := readLastContext(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if expected := "ctx1"; v != expected {
+		t.Fatalf("read wrong value=%q; expected=%q", v, expected)
+	}
+}
+
+func Test_kubectxFilePath(t *testing.T) {
+	origHome := os.Getenv("HOME")
+	os.Setenv("HOME", filepath.FromSlash("/foo/bar"))
+	defer os.Setenv("HOME", origHome)
+
+	expected := filepath.Join(filepath.FromSlash("/foo/bar"), ".kube", "kubectx")
+	v, err := kubectxPrevCtxFile()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if v != expected {
+		t.Fatalf("expected=%q got=%q", expected, v)
+	}
+}
+
+func Test_kubectxFilePath_error(t *testing.T) {
+	origHome := os.Getenv("HOME")
+	origUserprofile := os.Getenv("USERPROFILE")
+	os.Unsetenv("HOME")
+	os.Unsetenv("USERPROFILE")
+	defer os.Setenv("HOME", origHome)
+	defer os.Setenv("USERPROFILE", origUserprofile)
+
+	_, err := kubectxPrevCtxFile()
+	if err == nil {
+		t.Fatal(err)
+	}
+}
+
--- a/cmd/kubectx/switch.go
+++ b/cmd/kubectx/switch.go
@@ -0,0 +1,79 @@
+package main
+
+import (
+	"io"
+
+	"github.com/pkg/errors"
+
+	"github.com/ahmetb/kubectx/internal/cmdutil"
+	"github.com/ahmetb/kubectx/internal/kubeconfig"
+	"github.com/ahmetb/kubectx/internal/printer"
+)
+
+// SwitchOp indicates intention to switch contexts.
+type SwitchOp struct {
+	Target string // '-' for back and forth, or NAME
+}
+
+func (op SwitchOp) Run(_, stderr io.Writer) error {
+	var newCtx string
+	var err error
+	if op.Target == "-" {
+		newCtx, err = swapContext()
+	} else {
+		newCtx, err = switchContext(op.Target)
+	}
+	if err != nil {
+		return errors.Wrap(err, "failed to switch context")
+	}
+	err = printer.Success(stderr, "Switched to context %q.", newCtx)
+	return errors.Wrap(err, "print error")
+}
+
+// switchContext switches to specified context name.
+func switchContext(name string) (string, error) {
+	prevCtxFile, err := kubectxPrevCtxFile()
+	if err != nil {
+		return "", errors.Wrap(err, "failed to determine state file")
+	}
+
+	kc := new(kubeconfig.Kubeconfig).WithLoader(cmdutil.DefaultLoader)
+	defer kc.Close()
+	if err := kc.Parse(); err != nil {
+		return "", errors.Wrap(err, "kubeconfig error")
+	}
+
+	prev := kc.GetCurrentContext()
+	if !kc.ContextExists(name) {
+		return "", errors.Errorf("no context exists with the name: %q", name)
+	}
+	if err := kc.ModifyCurrentContext(name); err != nil {
+		return "", err
+	}
+	if err := kc.Save(); err != nil {
+		return "", errors.Wrap(err, "failed to save kubeconfig")
+	}
+
+	if prev != name {
+		if err := writeLastContext(prevCtxFile, prev); err != nil {
+			return "", errors.Wrap(err, "failed to save previous context name")
+		}
+	}
+	return name, nil
+}
+
+// swapContext switches to previously switch context.
+func swapContext() (string, error) {
+	prevCtxFile, err := kubectxPrevCtxFile()
+	if err != nil {
+		return "", errors.Wrap(err, "failed to determine state file")
+	}
+	prev, err := readLastContext(prevCtxFile)
+	if err != nil {
+		return "", errors.Wrap(err, "failed to read previous context file")
+	}
+	if prev == "" {
+		return "", errors.New("no previous context found")
+	}
+	return switchContext(prev)
+}
--- a/cmd/kubectx/unset.go
+++ b/cmd/kubectx/unset.go
@@ -0,0 +1,32 @@
+package main
+
+import (
+	"io"
+
+	"github.com/pkg/errors"
+
+	"github.com/ahmetb/kubectx/internal/cmdutil"
+	"github.com/ahmetb/kubectx/internal/kubeconfig"
+	"github.com/ahmetb/kubectx/internal/printer"
+)
+
+// UnsetOp indicates intention to remove current-context preference.
+type UnsetOp struct{}
+
+func (_ UnsetOp) Run(_, stderr io.Writer) error {
+	kc := new(kubeconfig.Kubeconfig).WithLoader(cmdutil.DefaultLoader)
+	defer kc.Close()
+	if err := kc.Parse(); err != nil {
+		return errors.Wrap(err, "kubeconfig error")
+	}
+
+	if err := kc.UnsetCurrentContext(); err != nil {
+		return errors.Wrap(err, "error while modifying current-context")
+	}
+	if err := kc.Save(); err != nil {
+		return errors.Wrap(err, "failed to save kubeconfig file after modification")
+	}
+
+	err := printer.Success(stderr, "Active context unset for kubectl.")
+	return errors.Wrap(err, "write error")
+}
--- a/cmd/kubens/current.go
+++ b/cmd/kubens/current.go
@@ -0,0 +1,32 @@
+package main
+
+import (
+	"fmt"
+	"io"
+
+	"github.com/pkg/errors"
+
+	"github.com/ahmetb/kubectx/internal/cmdutil"
+	"github.com/ahmetb/kubectx/internal/kubeconfig"
+)
+
+type CurrentOp struct{}
+
+func (c CurrentOp) Run(stdout, _ io.Writer) error {
+	kc := new(kubeconfig.Kubeconfig).WithLoader(cmdutil.DefaultLoader)
+	defer kc.Close()
+	if err := kc.Parse(); err != nil {
+		return errors.Wrap(err, "kubeconfig error")
+	}
+
+	ctx := kc.GetCurrentContext()
+	if ctx == "" {
+		return errors.New("current-context is not set")
+	}
+	ns, err := kc.NamespaceOfContext(ctx)
+	if err != nil {
+		return errors.Wrapf(err, "failed to read namespace of %q", ctx)
+	}
+	_, err = fmt.Fprintln(stdout, ns)
+	return errors.Wrap(err, "write error")
+}
--- a/cmd/kubens/flags.go
+++ b/cmd/kubens/flags.go
@@ -0,0 +1,43 @@
+package main
+
+import (
+	"fmt"
+	"io"
+	"os"
+	"strings"
+
+	"github.com/ahmetb/kubectx/internal/cmdutil"
+)
+
+// UnsupportedOp indicates an unsupported flag.
+type UnsupportedOp struct{ Err error }
+
+func (op UnsupportedOp) Run(_, _ io.Writer) error {
+	return op.Err
+}
+
+// parseArgs looks at flags (excl. executable name, i.e. argv[0])
+// and decides which operation should be taken.
+func parseArgs(argv []string) Op {
+	if len(argv) == 0 {
+		if cmdutil.IsInteractiveMode(os.Stdout) {
+			return InteractiveSwitchOp{SelfCmd: os.Args[0]}
+		}
+		return ListOp{}
+	}
+
+	if len(argv) == 1 {
+		v := argv[0]
+		if v == "--help" || v == "-h" {
+			return HelpOp{}
+		}
+		if v == "--current" || v == "-c" {
+			return CurrentOp{}
+		}
+		if strings.HasPrefix(v, "-") && v != "-" {
+			return UnsupportedOp{Err: fmt.Errorf("unsupported option '%s'", v)}
+		}
+		return SwitchOp{Target: argv[0]}
+	}
+	return UnsupportedOp{Err: fmt.Errorf("too many arguments")}
+}
--- a/cmd/kubens/flags_test.go
+++ b/cmd/kubens/flags_test.go
@@ -0,0 +1,63 @@
+package main
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/google/go-cmp/cmp"
+)
+
+func Test_parseArgs_new(t *testing.T) {
+	tests := []struct {
+		name string
+		args []string
+		want Op
+	}{
+		{name: "nil Args",
+			args: nil,
+			want: ListOp{}},
+		{name: "empty Args",
+			args: []string{},
+			want: ListOp{}},
+		{name: "help shorthand",
+			args: []string{"-h"},
+			want: HelpOp{}},
+		{name: "help long form",
+			args: []string{"--help"},
+			want: HelpOp{}},
+		{name: "current shorthand",
+			args: []string{"-c"},
+			want: CurrentOp{}},
+		{name: "current long form",
+			args: []string{"--current"},
+			want: CurrentOp{}},
+		{name: "switch by name",
+			args: []string{"foo"},
+			want: SwitchOp{Target: "foo"}},
+		{name: "switch by swap",
+			args: []string{"-"},
+			want: SwitchOp{Target: "-"}},
+		{name: "unrecognized flag",
+			args: []string{"-x"},
+			want: UnsupportedOp{Err: fmt.Errorf("unsupported option '-x'")}},
+		{name: "too many args",
+			args: []string{"a", "b", "c"},
+			want: UnsupportedOp{Err: fmt.Errorf("too many arguments")}},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := parseArgs(tt.args)
+
+			var opts cmp.Options
+			if _, ok := tt.want.(UnsupportedOp); ok {
+				opts = append(opts, cmp.Comparer(func(x, y UnsupportedOp) bool {
+					return (x.Err == nil && y.Err == nil) || (x.Err.Error() == y.Err.Error())
+				}))
+			}
+
+			if diff := cmp.Diff(got, tt.want, opts...); diff != "" {
+				t.Errorf("parseArgs(%#v) diff: %s", tt.args, diff)
+			}
+		})
+	}
+}
--- a/cmd/kubens/fzf.go
+++ b/cmd/kubens/fzf.go
@@ -0,0 +1,60 @@
+package main
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+	"os"
+	"os/exec"
+	"strings"
+
+	"github.com/pkg/errors"
+
+	"github.com/ahmetb/kubectx/internal/cmdutil"
+	"github.com/ahmetb/kubectx/internal/env"
+	"github.com/ahmetb/kubectx/internal/kubeconfig"
+	"github.com/ahmetb/kubectx/internal/printer"
+)
+
+type InteractiveSwitchOp struct {
+	SelfCmd string
+}
+
+// TODO(ahmetb) This method is heavily repetitive vs kubectx/fzf.go.
+func (op InteractiveSwitchOp) Run(_, stderr io.Writer) error {
+	// parse kubeconfig just to see if it can be loaded
+	kc := new(kubeconfig.Kubeconfig).WithLoader(cmdutil.DefaultLoader)
+	if err := kc.Parse(); err != nil {
+		if cmdutil.IsNotFoundErr(err) {
+			printer.Warning(stderr, "kubeconfig file not found")
+			return nil
+		}
+		return errors.Wrap(err, "kubeconfig error")
+	}
+	defer kc.Close()
+
+	cmd := exec.Command("fzf", "--ansi", "--no-preview")
+	var out bytes.Buffer
+	cmd.Stdin = os.Stdin
+	cmd.Stderr = stderr
+	cmd.Stdout = &out
+
+	cmd.Env = append(os.Environ(),
+		fmt.Sprintf("FZF_DEFAULT_COMMAND=%s", op.SelfCmd),
+		fmt.Sprintf("%s=1", env.EnvForceColor))
+	if err := cmd.Run(); err != nil {
+		if _, ok := err.(*exec.ExitError); !ok {
+			return err
+		}
+	}
+	choice := strings.TrimSpace(out.String())
+	if choice == "" {
+		return errors.New("you did not choose any of the options")
+	}
+	name, err := switchNamespace(kc, choice)
+	if err != nil {
+		return errors.Wrap(err, "failed to switch context")
+	}
+	printer.Success(stderr, "Switched to context %s.", printer.SuccessColor.Sprint(name))
+	return nil
+}
--- a/cmd/kubens/help.go
+++ b/cmd/kubens/help.go
@@ -0,0 +1,44 @@
+package main
+
+import (
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/pkg/errors"
+)
+
+// HelpOp describes printing help.
+type HelpOp struct{}
+
+func (_ HelpOp) Run(stdout, _ io.Writer) error {
+	return printUsage(stdout)
+}
+
+func printUsage(out io.Writer) error {
+	help := `USAGE:
+  %PROG%                    : list the namespaces in the current context
+  %PROG% <NAME>             : change the active namespace of current context
+  %PROG% -                  : switch to the previous namespace in this context
+  %PROG% -c, --current      : show the current namespace
+  %PROG% -h,--help          : show this message
+`
+	// TODO this replace logic is duplicated between this and kubectx
+	help = strings.ReplaceAll(help, "%PROG%", selfName())
+
+	_, err := fmt.Fprintf(out, "%s\n", help)
+	return errors.Wrap(err, "write error")
+}
+
+// selfName guesses how the user invoked the program.
+func selfName() string {
+	// TODO this method is duplicated between this and kubectx
+	me := filepath.Base(os.Args[0])
+	pluginPrefix := "kubectl-"
+	if strings.HasPrefix(me, pluginPrefix) {
+		return "kubectl " + strings.TrimPrefix(me, pluginPrefix)
+	}
+	return "kubectx"
+}
--- a/cmd/kubens/list.go
+++ b/cmd/kubens/list.go
@@ -0,0 +1,89 @@
+package main
+
+import (
+	"fmt"
+	"io"
+	"os"
+
+	"github.com/pkg/errors"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/client-go/kubernetes"
+	_ "k8s.io/client-go/plugin/pkg/client/auth"
+	"k8s.io/client-go/tools/clientcmd"
+
+	"github.com/ahmetb/kubectx/internal/cmdutil"
+	"github.com/ahmetb/kubectx/internal/kubeconfig"
+	"github.com/ahmetb/kubectx/internal/printer"
+)
+
+type ListOp struct{}
+
+func (op ListOp) Run(stdout, stderr io.Writer) error {
+	kc := new(kubeconfig.Kubeconfig).WithLoader(cmdutil.DefaultLoader)
+	defer kc.Close()
+	if err := kc.Parse(); err != nil {
+		return errors.Wrap(err, "kubeconfig error")
+	}
+
+	ctx := kc.GetCurrentContext()
+	if ctx == "" {
+		return errors.New("current-context is not set")
+	}
+	curNs, err := kc.NamespaceOfContext(ctx)
+	if err != nil {
+		return errors.Wrap(err, "cannot read current namespace")
+	}
+
+	ns, err := queryNamespaces(kc)
+	if err != nil {
+		return errors.Wrap(err, "could not list namespaces (is the cluster accessible?)")
+	}
+
+	for _, c := range ns {
+		s := c
+		if c == curNs {
+			s = printer.ActiveItemColor.Sprint(c)
+		}
+		fmt.Fprintf(stdout, "%s\n", s)
+	}
+	return nil
+}
+
+func queryNamespaces(kc *kubeconfig.Kubeconfig) ([]string, error) {
+	if os.Getenv("_MOCK_NAMESPACES") != "" {
+		return []string{"ns1","ns2"}, nil
+	}
+
+	b, err := kc.Bytes()
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to convert in-memory kubeconfig to yaml")
+	}
+	cfg, err := clientcmd.RESTConfigFromKubeConfig(b)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to initialize config")
+	}
+	clientset, err := kubernetes.NewForConfig(cfg)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to initialize k8s REST client")
+	}
+
+	var out []string
+	var next string
+	for {
+		list, err := clientset.CoreV1().Namespaces().List(metav1.ListOptions{
+			Limit:    500,
+			Continue: next,
+		})
+		if err != nil {
+			return nil, errors.Wrap(err, "failed to list namespaces from k8s API")
+		}
+		next = list.Continue
+		for _, it := range list.Items {
+			out = append(out, it.Name)
+		}
+		if next == "" {
+			break
+		}
+	}
+	return out, nil
+}
--- a/cmd/kubens/main.go
+++ b/cmd/kubens/main.go
@@ -0,0 +1,29 @@
+package main
+
+import (
+	"fmt"
+	"io"
+	"os"
+
+	"github.com/ahmetb/kubectx/internal/cmdutil"
+	"github.com/ahmetb/kubectx/internal/env"
+	"github.com/ahmetb/kubectx/internal/printer"
+)
+
+type Op interface {
+	Run(stdout, stderr io.Writer) error
+}
+
+func main() {
+	cmdutil.PrintDeprecatedEnvWarnings(os.Stderr, os.Environ())
+	op := parseArgs(os.Args[1:])
+	if err := op.Run(os.Stdout, os.Stderr); err != nil {
+		printer.Error(os.Stderr, err.Error())
+
+		if _, ok := os.LookupEnv(env.EnvDebug); ok {
+			// print stack trace in verbose mode
+			fmt.Fprintf(os.Stderr, "[DEBUG] error: %+v\n", err)
+		}
+		defer os.Exit(1)
+	}
+}
--- a/cmd/kubens/statefile.go
+++ b/cmd/kubens/statefile.go
@@ -0,0 +1,42 @@
+package main
+
+import (
+	"bytes"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+
+	"github.com/ahmetb/kubectx/internal/cmdutil"
+)
+
+var defaultDir = filepath.Join(cmdutil.HomeDir(), ".kube", "kubens")
+
+type NSFile struct {
+	dir string
+	ctx string
+}
+
+func NewNSFile(ctx string) NSFile { return NSFile{dir: defaultDir, ctx: ctx} }
+
+func (f NSFile) path() string { return filepath.Join(f.dir, f.ctx) }
+
+// Load reads the previous namespace setting, or returns empty if not exists.
+func (f NSFile) Load() (string, error) {
+	b, err := ioutil.ReadFile(f.path())
+	if err != nil {
+		if os.IsNotExist(err) {
+			return "", nil
+		}
+		return "", err
+	}
+	return string(bytes.TrimSpace(b)), nil
+}
+
+// Save stores the previous namespace information in the file.
+func (f NSFile) Save(value string) error {
+	d := filepath.Dir(f.path())
+	if err := os.MkdirAll(d, 0755); err != nil {
+		return err
+	}
+	return ioutil.WriteFile(f.path(), []byte(value), 0644)
+}
--- a/cmd/kubens/statefile_test.go
+++ b/cmd/kubens/statefile_test.go
@@ -0,0 +1,38 @@
+package main
+
+import (
+	"io/ioutil"
+	"os"
+	"testing"
+)
+
+func TestNSFile(t *testing.T) {
+	td, err := ioutil.TempDir(os.TempDir(), "")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer os.RemoveAll(td)
+
+	f := NewNSFile("foo")
+	f.dir = td
+	v, err := f.Load()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if v != "" {
+		t.Fatalf("Load() expected empty; got=%v", err)
+	}
+
+	err = f.Save("bar")
+	if err != nil {
+		t.Fatalf("Save() err=%v", err)
+	}
+
+	v, err = f.Load()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if expected := "bar"; v != expected {
+		t.Fatalf("Load()=%q; expected=%q", v, expected)
+	}
+}
--- a/cmd/kubens/switch.go
+++ b/cmd/kubens/switch.go
@@ -0,0 +1,89 @@
+package main
+
+import (
+	"io"
+
+	"github.com/pkg/errors"
+
+	"github.com/ahmetb/kubectx/internal/cmdutil"
+	"github.com/ahmetb/kubectx/internal/kubeconfig"
+	"github.com/ahmetb/kubectx/internal/printer"
+)
+
+type SwitchOp struct {
+	Target string // '-' for back and forth, or NAME
+}
+
+func (s SwitchOp) Run(_, stderr io.Writer) error {
+	kc := new(kubeconfig.Kubeconfig).WithLoader(cmdutil.DefaultLoader)
+	defer kc.Close()
+	if err := kc.Parse(); err != nil {
+		return errors.Wrap(err, "kubeconfig error")
+	}
+
+	toNS, err := switchNamespace(kc, s.Target)
+	if err != nil {
+		return err
+	}
+	err = printer.Success(stderr, "Active namespace is %q", toNS)
+	return err
+}
+
+func switchNamespace(kc *kubeconfig.Kubeconfig, ns string) (string, error) {
+	ctx := kc.GetCurrentContext()
+	if ctx == "" {
+		return "", errors.New("current-context is not set")
+	}
+	curNS, err := kc.NamespaceOfContext(ctx)
+	if ctx == "" {
+		return "", errors.New("failed to get current namespace")
+	}
+
+	f := NewNSFile(ctx)
+	prev, err := f.Load()
+	if err != nil {
+		return "", errors.Wrap(err, "failed to load previous namespace from file")
+	}
+
+	if ns == "-" {
+		if prev == "" {
+			return "", errors.Errorf("No previous namespace found for current context (%s)", ctx)
+		}
+		ns = prev
+	}
+
+	ok, err := namespaceExists(kc, ns)
+	if err != nil {
+		return "", errors.Wrap(err, "failed to query if namespace exists (is cluster accessible?)")
+	}
+	if !ok {
+		return "", errors.Errorf("no namespace exists with name %q", ns)
+	}
+
+	if err := kc.SetNamespace(ctx, ns); err != nil {
+		return "", errors.Wrapf(err, "failed to change to namespace %q", ns)
+	}
+	if err := kc.Save(); err != nil {
+		return "", errors.Wrap(err, "failed to save kubeconfig file")
+	}
+	if curNS != ns {
+		if err := f.Save(curNS); err != nil {
+			return "", errors.Wrap(err, "failed to save the previous namespace to file")
+		}
+	}
+	return ns, nil
+}
+
+
+func namespaceExists(kc *kubeconfig.Kubeconfig, ns string) (bool, error) {
+	nses, err := queryNamespaces(kc)
+	if err != nil {
+		return false, err
+	}
+	for _, v := range nses {
+		if v == ns {
+			return true, nil
+		}
+	}
+	return false, nil
+}
--- a/go.mod
+++ b/go.mod
@@ -0,0 +1,26 @@
+module github.com/ahmetb/kubectx
+
+go 1.14
+
+require (
+	facette.io/natsort v0.0.0-20181210072756-2cd4dd1e2dcb
+	github.com/elazarl/goproxy v0.0.0-20180725130230-947c36da3153 // indirect
+	github.com/fatih/color v1.9.0
+	github.com/gogo/protobuf v1.3.1 // indirect
+	github.com/google/go-cmp v0.4.0
+	github.com/google/gofuzz v1.1.0 // indirect
+	github.com/googleapis/gnostic v0.1.0 // indirect
+	github.com/imdario/mergo v0.3.9 // indirect
+	github.com/mattn/go-isatty v0.0.12
+	github.com/onsi/ginkgo v1.11.0 // indirect
+	github.com/pkg/errors v0.9.1
+	golang.org/x/oauth2 v0.0.0-20200107190931-bf48bf16ab8d // indirect
+	golang.org/x/time v0.0.0-20200416051211-89c76fbcd5d1 // indirect
+	gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c
+	k8s.io/apimachinery v0.17.0
+	k8s.io/client-go v0.17.0
+	k8s.io/kube-openapi v0.0.0-20200121204235-bf4fb3bd569c // indirect
+	k8s.io/utils v0.0.0-20200414100711-2df71ebbae66 // indirect
+	sigs.k8s.io/structured-merge-diff/v3 v3.0.0 // indirect
+	sigs.k8s.io/yaml v1.2.0 // indirect
+)
--- a/go.sum
+++ b/go.sum
@@ -0,0 +1,263 @@
+cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
+cloud.google.com/go v0.34.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
+cloud.google.com/go v0.38.0 h1:ROfEUZz+Gh5pa62DJWXSaonyu3StP6EA6lPEXPI6mCo=
+cloud.google.com/go v0.38.0/go.mod h1:990N+gfupTy94rShfmMCWGDn0LpTmnzTp2qbd1dvSRU=
+facette.io/natsort v0.0.0-20181210072756-2cd4dd1e2dcb h1:1pSweJFeR3Pqx7uoelppkzeegfUBXL6I2FFAbfXw570=
+facette.io/natsort v0.0.0-20181210072756-2cd4dd1e2dcb/go.mod h1:npRYmtaITVom7rcSo+pRURltHSG2r4TQM1cdqJ2dUB0=
+github.com/Azure/go-autorest/autorest v0.9.0 h1:MRvx8gncNaXJqOoLmhNjUAKh33JJF8LyxPhomEtOsjs=
+github.com/Azure/go-autorest/autorest v0.9.0/go.mod h1:xyHB1BMZT0cuDHU7I0+g046+BFDTQ8rEZB0s4Yfa6bI=
+github.com/Azure/go-autorest/autorest/adal v0.5.0 h1:q2gDruN08/guU9vAjuPWff0+QIrpH6ediguzdAzXAUU=
+github.com/Azure/go-autorest/autorest/adal v0.5.0/go.mod h1:8Z9fGy2MpX0PvDjB1pEgQTmVqjGhiHBW7RJJEciWzS0=
+github.com/Azure/go-autorest/autorest/date v0.1.0 h1:YGrhWfrgtFs84+h0o46rJrlmsZtyZRg470CqAXTZaGM=
+github.com/Azure/go-autorest/autorest/date v0.1.0/go.mod h1:plvfp3oPSKwf2DNjlBjWF/7vwR+cUD/ELuzDCXwHUVA=
+github.com/Azure/go-autorest/autorest/mocks v0.1.0/go.mod h1:OTyCOPRA2IgIlWxVYxBee2F5Gr4kF2zd2J5cFRaIDN0=
+github.com/Azure/go-autorest/autorest/mocks v0.2.0/go.mod h1:OTyCOPRA2IgIlWxVYxBee2F5Gr4kF2zd2J5cFRaIDN0=
+github.com/Azure/go-autorest/logger v0.1.0 h1:ruG4BSDXONFRrZZJ2GUXDiUyVpayPmb1GnWeHDdaNKY=
+github.com/Azure/go-autorest/logger v0.1.0/go.mod h1:oExouG+K6PryycPJfVSxi/koC6LSNgds39diKLz7Vrc=
+github.com/Azure/go-autorest/tracing v0.5.0 h1:TRn4WjSnkcSy5AEG3pnbtFSwNtwzjr4VYyQflFE619k=
+github.com/Azure/go-autorest/tracing v0.5.0/go.mod h1:r/s2XiOKccPW3HrqB+W0TQzfbtp2fGCgRFtBroKn4Dk=
+github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
+github.com/NYTimes/gziphandler v0.0.0-20170623195520-56545f4a5d46/go.mod h1:3wb06e3pkSAbeQ52E9H9iFoQsEEwGN64994WTCIhntQ=
+github.com/PuerkitoBio/purell v1.0.0/go.mod h1:c11w/QuzBsJSee3cPx9rAFu61PvFxuPbtSwDGJws/X0=
+github.com/PuerkitoBio/urlesc v0.0.0-20160726150825-5bd2802263f2/go.mod h1:uGdkoq3SwY9Y+13GIhn11/XLaGBb4BfwItxLd5jeuXE=
+github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw=
+github.com/davecgh/go-spew v0.0.0-20151105211317-5215b55f46b2/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/dgrijalva/jwt-go v3.2.0+incompatible h1:7qlOGliEKZXTDg6OTjfoBKDXWrumCAMpl/TFQ4/5kLM=
+github.com/dgrijalva/jwt-go v3.2.0+incompatible/go.mod h1:E3ru+11k8xSBh+hMPgOLZmtrrCbhqsmaPHjLKYnJCaQ=
+github.com/docker/spdystream v0.0.0-20160310174837-449fdfce4d96/go.mod h1:Qh8CwZgvJUkLughtfhJv5dyTYa91l1fOUCrgjqmcifM=
+github.com/elazarl/goproxy v0.0.0-20170405201442-c4fc26588b6e/go.mod h1:/Zj4wYkgs4iZTTu3o/KG3Itv/qCCa8VVMlb3i9OVuzc=
+github.com/elazarl/goproxy v0.0.0-20180725130230-947c36da3153/go.mod h1:/Zj4wYkgs4iZTTu3o/KG3Itv/qCCa8VVMlb3i9OVuzc=
+github.com/emicklei/go-restful v0.0.0-20170410110728-ff4f55a20633/go.mod h1:otzb+WCGbkyDHkqmQmT5YD2WR4BBwUdeQoFo8l/7tVs=
+github.com/evanphx/json-patch v4.2.0+incompatible/go.mod h1:50XU6AFN0ol/bzJsmQLiYLvXMP4fmwYFNcr97nuDLSk=
+github.com/fatih/color v1.9.0 h1:8xPHl4/q1VyqGIPif1F+1V3Y3lSmrq01EabUW3CoW5s=
+github.com/fatih/color v1.9.0/go.mod h1:eQcE1qtQxscV5RaZvpXrrb8Drkc3/DdQ+uUYCNjL+zU=
+github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
+github.com/ghodss/yaml v0.0.0-20150909031657-73d445a93680/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04=
+github.com/go-logr/logr v0.1.0/go.mod h1:ixOQHD9gLJUVQQ2ZOR7zLEifBX6tGkNJF4QyIY7sIas=
+github.com/go-openapi/jsonpointer v0.0.0-20160704185906-46af16f9f7b1/go.mod h1:+35s3my2LFTysnkMfxsJBAMHj/DoqoB9knIWoYG/Vk0=
+github.com/go-openapi/jsonreference v0.0.0-20160704190145-13c6e3589ad9/go.mod h1:W3Z9FmVs9qj+KR4zFKmDPGiLdk1D9Rlm7cyMvf57TTg=
+github.com/go-openapi/spec v0.0.0-20160808142527-6aced65f8501/go.mod h1:J8+jY1nAiCcj+friV/PDoE1/3eeccG9LYBs0tYvLOWc=
+github.com/go-openapi/swag v0.0.0-20160704191624-1d0bd113de87/go.mod h1:DXUve3Dpr1UfpPtxFw+EFuQ41HhCWZfha5jSVRG7C7I=
+github.com/gogo/protobuf v1.2.2-0.20190723190241-65acae22fc9d/go.mod h1:SlYgWuQ5SjCEi6WLHjHCa1yvBfUnHcTbrrZtXPKa29o=
+github.com/gogo/protobuf v1.3.1 h1:DqDEcV5aeaTmdFBePNpYsp3FlcVH/2ISVVM9Qf8PSls=
+github.com/gogo/protobuf v1.3.1/go.mod h1:SlYgWuQ5SjCEi6WLHjHCa1yvBfUnHcTbrrZtXPKa29o=
+github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q=
+github.com/golang/groupcache v0.0.0-20160516000752-02826c3e7903/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
+github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
+github.com/golang/mock v1.2.0/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
+github.com/golang/protobuf v0.0.0-20161109072736-4bd1920723d7/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
+github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
+github.com/golang/protobuf v1.3.2 h1:6nsPYzhq5kReh6QImI3k5qWzO4PEbvbIW2cwSfR/6xs=
+github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
+github.com/google/btree v0.0.0-20180813153112-4030bb1f1f0c/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ=
+github.com/google/btree v1.0.0/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ=
+github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M=
+github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
+github.com/google/go-cmp v0.4.0 h1:xsAVV57WRhGj6kEIi8ReJzQlHHqcBYCElAvkovg3B/4=
+github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/gofuzz v0.0.0-20161122191042-44d81051d367/go.mod h1:HP5RmnzzSNb993RKQDq4+1A4ia9nllfqcQFTQJedwGI=
+github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
+github.com/google/gofuzz v1.1.0 h1:Hsa8mG0dQ46ij8Sl2AYJDUv1oA9/d6Vk+3LG99Oe02g=
+github.com/google/gofuzz v1.1.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
+github.com/google/martian v2.1.0+incompatible/go.mod h1:9I4somxYTbIHy5NJKHRl3wXiIaQGbYVAs8BPL6v8lEs=
+github.com/google/pprof v0.0.0-20181206194817-3ea8567a2e57/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc=
+github.com/google/uuid v1.1.1/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/googleapis/gax-go/v2 v2.0.4/go.mod h1:0Wqv26UfaUD9n4G6kQubkQ+KchISgw+vpHVxEJEs9eg=
+github.com/googleapis/gnostic v0.0.0-20170729233727-0c5108395e2d/go.mod h1:sJBsCZ4ayReDTBIg8b9dl28c5xFWyhBTVRp3pOg5EKY=
+github.com/googleapis/gnostic v0.1.0 h1:rVsPeBmXbYv4If/cumu1AzZPwV58q433hvONV1UEZoI=
+github.com/googleapis/gnostic v0.1.0/go.mod h1:sJBsCZ4ayReDTBIg8b9dl28c5xFWyhBTVRp3pOg5EKY=
+github.com/gophercloud/gophercloud v0.1.0 h1:P/nh25+rzXouhytV2pUHBb65fnds26Ghl8/391+sT5o=
+github.com/gophercloud/gophercloud v0.1.0/go.mod h1:vxM41WHh5uqHVBMZHzuwNOHh8XEoIEcSTewFxm1c5g8=
+github.com/gregjones/httpcache v0.0.0-20180305231024-9cad4c3443a7/go.mod h1:FecbI9+v66THATjSRHfNgh1IVFe/9kFxbXtjV0ctIMA=
+github.com/hashicorp/golang-lru v0.5.0/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8=
+github.com/hashicorp/golang-lru v0.5.1/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8=
+github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU=
+github.com/imdario/mergo v0.3.5/go.mod h1:2EnlNZ0deacrJVfApfmtdGgDfMuh/nq6Ok1EcJh5FfA=
+github.com/imdario/mergo v0.3.9 h1:UauaLniWCFHWd+Jp9oCEkTBj8VO/9DKg3PV3VCNMDIg=
+github.com/imdario/mergo v0.3.9/go.mod h1:2EnlNZ0deacrJVfApfmtdGgDfMuh/nq6Ok1EcJh5FfA=
+github.com/json-iterator/go v0.0.0-20180612202835-f2b4162afba3/go.mod h1:+SdeFBvtyEkXs7REEP0seUULqWtbJapLOCVDaaPEHmU=
+github.com/json-iterator/go v1.1.6/go.mod h1:+SdeFBvtyEkXs7REEP0seUULqWtbJapLOCVDaaPEHmU=
+github.com/json-iterator/go v1.1.8 h1:QiWkFLKq0T7mpzwOTu6BzNDbfTE8OLrYhVKYMLF46Ok=
+github.com/json-iterator/go v1.1.8/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4=
+github.com/jstemmer/go-junit-report v0.0.0-20190106144839-af01ea7f8024/go.mod h1:6v2b51hI/fHJwM22ozAgKL4VKDeJcHhJFhtBdhmNjmU=
+github.com/kisielk/errcheck v1.2.0/go.mod h1:/BMXB+zMLi60iA8Vv6Ksmxu/1UDYcXs4uQLJ+jE2L00=
+github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck=
+github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
+github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
+github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
+github.com/mailru/easyjson v0.0.0-20160728113105-d5b7844b561a/go.mod h1:C1wdFJiN94OJF2b5HbByQZoLdCWB1Yqtg26g4irojpc=
+github.com/mattn/go-colorable v0.1.4 h1:snbPLB8fVfU9iwbbo30TPtbLRzwWu6aJS6Xh4eaaviA=
+github.com/mattn/go-colorable v0.1.4/go.mod h1:U0ppj6V5qS13XJ6of8GYAs25YV2eR4EVcfRqFIhoBtE=
+github.com/mattn/go-isatty v0.0.8/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s=
+github.com/mattn/go-isatty v0.0.11 h1:FxPOTFNqGkuDUGi3H/qkUbQO4ZiBa2brKq5r0l8TGeM=
+github.com/mattn/go-isatty v0.0.11/go.mod h1:PhnuNfih5lzO57/f3n+odYbM4JtupLOxQOAqxQCu2WE=
+github.com/mattn/go-isatty v0.0.12 h1:wuysRhFDzyxgEmMf5xjvJ2M9dZoWAXNNr5LSBS7uHXY=
+github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU=
+github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
+github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg=
+github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
+github.com/modern-go/reflect2 v0.0.0-20180320133207-05fbef0ca5da/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
+github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
+github.com/modern-go/reflect2 v1.0.1 h1:9f412s+6RmYXLWZSEzVVgPGK7C2PphHj5RJrvfx9AWI=
+github.com/modern-go/reflect2 v1.0.1/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
+github.com/munnerz/goautoneg v0.0.0-20120707110453-a547fc61f48d/go.mod h1:+n7T8mK8HuQTcFwEeznm/DIxMOiR9yIdICNftLE1DvQ=
+github.com/mxk/go-flowrate v0.0.0-20140419014527-cca7078d478f/go.mod h1:ZdcZmHo+o7JKHSa8/e818NopupXU1YMK5fe1lsApnBw=
+github.com/onsi/ginkgo v0.0.0-20170829012221-11459a886d9c/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
+github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
+github.com/onsi/ginkgo v1.10.1/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
+github.com/onsi/ginkgo v1.11.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
+github.com/onsi/gomega v0.0.0-20170829124025-dcabb60a477c/go.mod h1:C1qb7wdrVGGVU+Z6iS04AVkA3Q65CEZX59MT0QO5uiA=
+github.com/onsi/gomega v1.7.0/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY=
+github.com/peterbourgon/diskv v2.0.1+incompatible/go.mod h1:uqqh8zWWbv1HBMNONnaR/tNboyR3/BZd58JJSHlUSCU=
+github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
+github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/pmezard/go-difflib v0.0.0-20151028094244-d8ed2627bdf0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/spf13/afero v1.2.2/go.mod h1:9ZxEEn6pIJ8Rxe320qSDBk6AsU0r9pR7Q4OcevTdifk=
+github.com/spf13/pflag v0.0.0-20170130214245-9ff6c6923cff/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4=
+github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA=
+github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/testify v0.0.0-20151208002404-e3a8ff8ce365/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
+github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
+github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
+go.opencensus.io v0.21.0/go.mod h1:mSImk1erAIZhrmZN+AvHh14ztQfjbGwt4TtuofqLduU=
+golang.org/x/crypto v0.0.0-20190211182817-74369b46fc67/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
+golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2 h1:VklqNMn3ovrHsnt90PveolxSbWFaJdECFbxSq0Mqo2M=
+golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
+golang.org/x/crypto v0.0.0-20190820162420-60c769a6c586 h1:7KByu05hhLed2MO29w7p1XfZvZ13m8mub3shuVftRs0=
+golang.org/x/crypto v0.0.0-20190820162420-60c769a6c586/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
+golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
+golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
+golang.org/x/lint v0.0.0-20190227174305-5b3e6a55c961/go.mod h1:wehouNa3lNwaWXcvxsM5YxQ5yQlVC4a0KAMCusXpPoU=
+golang.org/x/lint v0.0.0-20190301231843-5614ed5bae6f/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
+golang.org/x/net v0.0.0-20170114055629-f2499483f923/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20190108225652-1e06a53dbb7e/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20190213061140-3a22650c66bd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20191004110552-13f9640d40b9 h1:rjwSpXsdiK0dV8/Naq3kAw9ymfAeJIyd0upUIElB+lI=
+golang.org/x/net v0.0.0-20191004110552-13f9640d40b9/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
+golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
+golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
+golang.org/x/oauth2 v0.0.0-20200107190931-bf48bf16ab8d h1:TzXSXBo42m9gQenoE3b9BGiEpg5IG2JkU5FkPIawgtw=
+golang.org/x/oauth2 v0.0.0-20200107190931-bf48bf16ab8d/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
+golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20190227155943-e225da77a7e6/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sys v0.0.0-20170830134202-bb24a47a89ea/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190209173611-3b5209105503/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190222072716-a9d3bda3a223/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190826190057-c7b8b68b1456/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191022100944-742c48ecaeb7/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191026070338-33540a1f6037 h1:YyJpGZS1sBuBCzLAR1VEpK193GlqGZbnPFnPV/5Rsb4=
+golang.org/x/sys v0.0.0-20191026070338-33540a1f6037/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200116001909-b77594299b42 h1:vEOn+mP2zCOVzKckCZy6YsCtDblrpj/w7B9nxGNELpg=
+golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/text v0.0.0-20160726164857-2910a502d2bf/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/text v0.3.1-0.20180807135948-17ff2d5776d2/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/text v0.3.2 h1:tW2bmiBqwgJj/UpqtC8EpXEZVYOwU0yG4iWbprSVAcs=
+golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
+golang.org/x/time v0.0.0-20181108054448-85acf8d2951c/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
+golang.org/x/time v0.0.0-20190308202827-9d24e82272b4/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
+golang.org/x/time v0.0.0-20200416051211-89c76fbcd5d1 h1:NusfzzA6yGQ+ua51ck7E3omNUX/JuqbFSaRGqU8CcLI=
+golang.org/x/time v0.0.0-20200416051211-89c76fbcd5d1/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
+golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20181011042414-1f849cf54d09/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20181030221726-6c7e314b6563/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20190114222345-bf090417da8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20190226205152-f727befe758c/go.mod h1:9Yl7xja0Znq3iFh3HoIrodX9oNMXvdceNzlUR8zjMvY=
+golang.org/x/tools v0.0.0-20190312170243-e65039ee4138/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543 h1:E7g+9GITq07hpfrRu66IVDexMakfv52eLZ2CXBWiKr4=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+google.golang.org/api v0.4.0/go.mod h1:8k5glujaEP+g9n7WNsDg8QP6cUVNI86fCNMcbazEtwE=
+google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM=
+google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
+google.golang.org/appengine v1.5.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
+google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc=
+google.golang.org/genproto v0.0.0-20190307195333-5fe7a883aa19/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
+google.golang.org/genproto v0.0.0-20190418145605-e7d98fc518a7/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
+google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys=
+gopkg.in/inf.v0 v0.9.1 h1:73M5CoZyi3ZLMOyDlQh031Cx6N9NDJ2Vvfl76EDAgDc=
+gopkg.in/inf.v0 v0.9.1/go.mod h1:cWUDdTG/fYaXco+Dcufb5Vnc6Gp2YChqWtbxRZE0mXw=
+gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw=
+gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.2.4/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.2.8 h1:obN1ZagJSUGI0Ek/LBmuj4SNLPfIny3KsKFopxRdj10=
+gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c h1:dUUwHk2QECo/6vqA44rthZ8ie2QXMNeKRTHCNY2nXvo=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
+honnef.co/go/tools v0.0.0-20190106161140-3f1c8253044a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
+k8s.io/api v0.17.0 h1:H9d/lw+VkZKEVIUc8F3wgiQ+FUXTTr21M87jXLU7yqM=
+k8s.io/api v0.17.0/go.mod h1:npsyOePkeP0CPwyGfXDHxvypiYMJxBWAMpQxCaJ4ZxI=
+k8s.io/api v0.17.1-beta.0/go.mod h1:t+ColJ7ZemYM/LXgLo4sVuO86DluzcnNHVKfZK4irZM=
+k8s.io/api v0.17.1/go.mod h1:zxiAc5y8Ngn4fmhWUtSxuUlkfz1ixT7j9wESokELzOg=
+k8s.io/api v0.17.2/go.mod h1:BS9fjjLc4CMuqfSO8vgbHPKMt5+SF0ET6u/RVDihTo4=
+k8s.io/api v0.17.3-beta.0/go.mod h1:II7E2nD74NziEP/I5++IpJ/E4xAnLSVSxsWjEY7nTJc=
+k8s.io/api v0.17.3/go.mod h1:YZ0OTkuw7ipbe305fMpIdf3GLXZKRigjtZaV5gzC2J0=
+k8s.io/api v0.17.4-beta.0/go.mod h1:GvrPCgJXMjQy7jNXQyJTEtLb97iKYOPIRHf12YpPgsg=
+k8s.io/api v0.17.4/go.mod h1:5qxx6vjmwUVG2nHQTKGlLts8Tbok8PzHl4vHtVFuZCA=
+k8s.io/api v0.17.5-beta.0/go.mod h1:KZb7OowZyrErfJIgFiNbvk8Mz27wiFdZJzgoOg3Ij3k=
+k8s.io/api v0.17.5/go.mod h1:0zV5/ungglgy2Rlm3QK8fbxkXVs+BSJWpJP/+8gUVLY=
+k8s.io/api v0.17.6-beta.0/go.mod h1:VidxcyvUtKF2+Hul10U4/nUiefO2ZPcMffUpPx0a6F4=
+k8s.io/api v0.18.0-alpha.1/go.mod h1:X82bXHlVEfxpVA9rO5PMaSOdQ+VdlSjT9A2Tl/CWL4A=
+k8s.io/api v0.18.0-alpha.2/go.mod h1:jmDzGjASmjc+X3sojto6zy8iHsZEpgdnqHz0aWfRTEg=
+k8s.io/api v0.18.0-alpha.4/go.mod h1:SvC64HywGrMEvfBPw7FcGXhoKTBfkFrpbuCoS2/gdiA=
+k8s.io/api v0.18.0-alpha.5/go.mod h1:4R9YKKdSnQmR4J01O1TXy0QMouQ6r46A+9kwfhV7rZk=
+k8s.io/api v0.18.0-beta.0/go.mod h1:VrRplS6LnRDM5Iq8CeqbtMAaAGU2iZDEoO3qNUe32FQ=
+k8s.io/api v0.18.0-beta.1/go.mod h1:NcLIcCLuI/dH9R6reQzXe8l3GZMBqYyV7IpCg8ELWNw=
+k8s.io/api v0.18.0-beta.2/go.mod h1:2oeNnWEqcSmaM/ibSh3t7xcIqbkGXhzZdn4ezV9T4m0=
+k8s.io/api v0.18.0-rc.1/go.mod h1:ZOh6SbHjOYyaMLlWmB2+UOQKEWDpCnVEVpEyt7S2J9s=
+k8s.io/api v0.18.0/go.mod h1:q2HRQkfDzHMBZL9l/y9rH63PkQl4vae0xRT+8prbrK8=
+k8s.io/api v0.18.1-beta.0/go.mod h1:xZ5sMb6uqkZxXjcN6D2st2inR6dSqMs935Na0rw/1h4=
+k8s.io/api v0.18.1/go.mod h1:3My4jorQWzSs5a+l7Ge6JBbIxChLnY8HnuT58ZWolss=
+k8s.io/api v0.18.2-beta.0/go.mod h1:OdO5IPycJkPS91wMkDJJd/yfJpgZukVaxs0MA20Wn6g=
+k8s.io/api v0.18.2 h1:wG5g5ZmSVgm5B+eHMIbI9EGATS2L8Z72rda19RIEgY8=
+k8s.io/api v0.18.2/go.mod h1:SJCWI7OLzhZSvbY7U8zwNl9UA4o1fizoug34OV/2r78=
+k8s.io/apimachinery v0.17.0 h1:xRBnuie9rXcPxUkDizUsGvPf1cnlZCFu210op7J7LJo=
+k8s.io/apimachinery v0.17.0/go.mod h1:b9qmWdKlLuU9EBh+06BtLcSf/Mu89rWL33naRxs1uZg=
+k8s.io/apimachinery v0.18.2 h1:44CmtbmkzVDAhCpRVSiP2R5PPrC2RtlIv/MoB8xpdRA=
+k8s.io/apimachinery v0.18.2/go.mod h1:9SnR/e11v5IbyPCGbvJViimtJ0SwHG4nfZFjU77ftcA=
+k8s.io/client-go v0.17.0 h1:8QOGvUGdqDMFrm9sD6IUFl256BcffynGoe80sxgTEDg=
+k8s.io/client-go v0.17.0/go.mod h1:TYgR6EUHs6k45hb6KWjVD6jFZvJV4gHDikv/It0xz+k=
+k8s.io/client-go v1.5.1 h1:XaX/lo2/u3/pmFau8HN+sB5C/b4dc4Dmm2eXjBH4p1E=
+k8s.io/client-go v11.0.0+incompatible h1:LBbX2+lOwY9flffWlJM7f1Ct8V2SRNiMRDFeiwnJo9o=
+k8s.io/client-go v11.0.0+incompatible/go.mod h1:7vJpHMYJwNQCWgzmNV+VYUl1zCObLyodBc8nIyt8L5s=
+k8s.io/gengo v0.0.0-20190128074634-0689ccc1d7d6/go.mod h1:ezvh/TsK7cY6rbqRK0oQQ8IAqLxYwwyPxAX1Pzy0ii0=
+k8s.io/klog v0.0.0-20181102134211-b9b56d5dfc92/go.mod h1:Gq+BEi5rUBO/HRz0bTSXDUcqjScdoY3a9IHpCEIOOfk=
+k8s.io/klog v0.3.0/go.mod h1:Gq+BEi5rUBO/HRz0bTSXDUcqjScdoY3a9IHpCEIOOfk=
+k8s.io/klog v1.0.0 h1:Pt+yjF5aB1xDSVbau4VsWe+dQNzA0qv1LlXdC2dF6Q8=
+k8s.io/klog v1.0.0/go.mod h1:4Bi6QPql/J/LkTDqv7R/cd3hPo4k2DG6Ptcz060Ez5I=
+k8s.io/klog/v2 v2.0.0/go.mod h1:PBfzABfn139FHAV07az/IF9Wp1bkk3vpT2XSJ76fSDE=
+k8s.io/kube-openapi v0.0.0-20191107075043-30be4d16710a/go.mod h1:1TqjTSzOxsLGIKfj0lK8EeCP7K1iUG65v09OM0/WG5E=
+k8s.io/kube-openapi v0.0.0-20200121204235-bf4fb3bd569c/go.mod h1:GRQhZsXIAJ1xR0C9bd8UpWHZ5plfAS9fzPjJuQ6JL3E=
+k8s.io/utils v0.0.0-20191114184206-e782cd3c129f/go.mod h1:sZAwmy6armz5eXlNoLmJcl4F1QuKu7sr+mFQ0byX7Ew=
+k8s.io/utils v0.0.0-20200414100711-2df71ebbae66 h1:Ly1Oxdu5p5ZFmiVT71LFgeZETvMfZ1iBIGeOenT2JeM=
+k8s.io/utils v0.0.0-20200414100711-2df71ebbae66/go.mod h1:jPW/WVKK9YHAvNhRxK0md/EJ228hCsBRufyofKtW8HA=
+sigs.k8s.io/structured-merge-diff v0.0.0-20190525122527-15d366b2352e h1:4Z09Hglb792X0kfOBBJUPFEyvVfQWrYT/l8h5EKA6JQ=
+sigs.k8s.io/structured-merge-diff v0.0.0-20190525122527-15d366b2352e/go.mod h1:wWxsB5ozmmv/SG7nM11ayaAW51xMvak/t1r0CSlcokI=
+sigs.k8s.io/structured-merge-diff/v3 v3.0.0-20200116222232-67a7b8c61874/go.mod h1:PlARxl6Hbt/+BC80dRLi1qAmnMqwqDg62YvvVkZjemw=
+sigs.k8s.io/structured-merge-diff/v3 v3.0.0 h1:dOmIZBMfhcHS09XZkMyUgkq5trg3/jRyJYFZUiaOp8E=
+sigs.k8s.io/structured-merge-diff/v3 v3.0.0/go.mod h1:PlARxl6Hbt/+BC80dRLi1qAmnMqwqDg62YvvVkZjemw=
+sigs.k8s.io/yaml v1.1.0/go.mod h1:UJmg0vDUVViEyp3mgSv9WPwZCDxu4rQW1olrI1uml+o=
+sigs.k8s.io/yaml v1.2.0 h1:kr/MCeFWJWTwyaHoR9c8EjH9OumOmoF9YGiZd7lFm/Q=
+sigs.k8s.io/yaml v1.2.0/go.mod h1:yfXDCHCao9+ENCvLSE62v9VSji2MKu5jeNfTrofGhJc=
--- a/internal/cmdutil/deprecated.go
+++ b/internal/cmdutil/deprecated.go
@@ -0,0 +1,22 @@
+package cmdutil
+
+import (
+	"io"
+	"strings"
+
+	"github.com/ahmetb/kubectx/internal/printer"
+)
+
+func PrintDeprecatedEnvWarnings(out io.Writer, vars []string) {
+	for _, vv := range vars {
+		parts := strings.SplitN(vv, "=", 2)
+		if len(parts) != 2 {
+			continue
+		}
+		key := parts[0]
+
+		if key == `KUBECTX_CURRENT_FGCOLOR` || key == `KUBECTX_CURRENT_BGCOLOR` {
+				printer.Warning(out,"%s environment variable is now deprecated", key)
+		}
+	}
+}
--- a/internal/cmdutil/deprecated_test.go
+++ b/internal/cmdutil/deprecated_test.go
@@ -0,0 +1,35 @@
+package cmdutil
+
+import (
+	"bytes"
+	"strings"
+	"testing"
+)
+
+func TestPrintDeprecatedEnvWarnings_noDeprecatedVars(t *testing.T){
+	var out bytes.Buffer
+	PrintDeprecatedEnvWarnings(&out, []string{
+		"A=B",
+		"PATH=/foo:/bar:/bin",
+	})
+	if v := out.String(); len(v) > 0{
+		t.Fatalf("something written to buf: %v", v)
+	}
+}
+
+
+func TestPrintDeprecatedEnvWarnings_bgColors(t *testing.T){
+	var out bytes.Buffer
+
+	PrintDeprecatedEnvWarnings(&out, []string{
+		"KUBECTX_CURRENT_FGCOLOR=1",
+		"KUBECTX_CURRENT_BGCOLOR=2",
+	})
+	v := out.String()
+	if !strings.Contains(v, "KUBECTX_CURRENT_FGCOLOR"){
+		t.Fatalf("output doesn't contain 'KUBECTX_CURRENT_FGCOLOR': %q", v)
+	}
+	if !strings.Contains(v, "KUBECTX_CURRENT_BGCOLOR"){
+		t.Fatalf("output doesn't contain 'KUBECTX_CURRENT_BGCOLOR': %q", v)
+	}
+}
--- a/internal/cmdutil/interactive.go
+++ b/internal/cmdutil/interactive.go
@@ -0,0 +1,30 @@
+package cmdutil
+
+import (
+	"os"
+	"os/exec"
+
+	"github.com/mattn/go-isatty"
+
+	"github.com/ahmetb/kubectx/internal/env"
+)
+
+// isTerminal determines if given fd is a TTY.
+func isTerminal(fd *os.File) bool {
+	return isatty.IsTerminal(fd.Fd())
+}
+
+// fzfInstalled determines if fzf(1) is in PATH.
+func fzfInstalled() bool {
+	v, _ := exec.LookPath("fzf")
+	if v != "" {
+		return true
+	}
+	return false
+}
+
+// IsInteractiveMode determines if we can do choosing with fzf.
+func IsInteractiveMode(stdout *os.File) bool {
+	v := os.Getenv(env.EnvFZFIgnore)
+	return v == "" && isTerminal(stdout) && fzfInstalled()
+}
--- a/internal/cmdutil/kubeconfigloader.go
+++ b/internal/cmdutil/kubeconfigloader.go
@@ -0,0 +1,82 @@
+package cmdutil
+
+import (
+	"os"
+	"path/filepath"
+
+	"github.com/pkg/errors"
+
+	"github.com/ahmetb/kubectx/internal/kubeconfig"
+)
+
+var (
+	DefaultLoader kubeconfig.Loader = new(StandardKubeconfigLoader)
+)
+
+type StandardKubeconfigLoader struct{}
+
+type kubeconfigFile struct{ *os.File }
+
+func (*StandardKubeconfigLoader) Load() (kubeconfig.ReadWriteResetCloser, error) {
+	cfgPath, err := kubeconfigPath()
+	if err != nil {
+		return nil, errors.Wrap(err, "cannot determine kubeconfig path")
+	}
+	f, err := os.OpenFile(cfgPath, os.O_RDWR, 0)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return nil, errors.Wrap(err, "kubeconfig file not found")
+		}
+		return nil, errors.Wrap(err, "failed to open file")
+	}
+	return &kubeconfigFile{f}, nil
+}
+
+func (kf *kubeconfigFile) Reset() error {
+	if err := kf.Truncate(0); err != nil {
+		return errors.Wrap(err, "failed to truncate file")
+	}
+	_, err := kf.Seek(0, 0)
+	return errors.Wrap(err, "failed to seek in file")
+}
+
+func kubeconfigPath() (string, error) {
+	// KUBECONFIG env var
+	if v := os.Getenv("KUBECONFIG"); v != "" {
+		list := filepath.SplitList(v)
+		if len(list) > 1 {
+			// TODO KUBECONFIG=file1:file2 currently not supported
+			return "", errors.New("multiple files in KUBECONFIG are currently not supported")
+		}
+		return v, nil
+	}
+
+	// default path
+	home := HomeDir()
+	if home == "" {
+		return "", errors.New("HOME or USERPROFILE environment variable not set")
+	}
+	return filepath.Join(home, ".kube", "config"), nil
+}
+
+func HomeDir() string {
+	if v := os.Getenv("XDG_CACHE_HOME"); v != "" {
+		return v
+	}
+	home := os.Getenv("HOME")
+	if home == "" {
+		home = os.Getenv("USERPROFILE") // windows
+	}
+	return home
+}
+
+// IsNotFoundErr determines if the underlying error is os.IsNotExist. Right now
+// errors from github.com/pkg/errors doesn't work with os.IsNotExist.
+func IsNotFoundErr(err error) bool {
+	for e := err; e != nil; e = errors.Unwrap(e) {
+		if os.IsNotExist(e) {
+			return true
+		}
+	}
+	return false
+}
--- a/internal/cmdutil/kubeconfigloader_test.go
+++ b/internal/cmdutil/kubeconfigloader_test.go
@@ -0,0 +1,130 @@
+package cmdutil
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/ahmetb/kubectx/internal/kubeconfig"
+	"github.com/ahmetb/kubectx/internal/testutil"
+)
+
+func Test_homeDir(t *testing.T) {
+	type env struct{ k, v string }
+	cases := []struct {
+		name string
+		envs []env
+		want string
+	}{
+		{
+			name: "XDG_CACHE_HOME precedence",
+			envs: []env{
+				{"XDG_CACHE_HOME", "xdg"},
+				{"HOME", "home"},
+			},
+			want: "xdg",
+		},
+		{
+			name: "HOME over USERPROFILE",
+			envs: []env{
+				{"HOME", "home"},
+				{"USERPROFILE", "up"},
+			},
+			want: "home",
+		},
+		{
+			name: "only USERPROFILE available",
+			envs: []env{
+				{"XDG_CACHE_HOME", ""},
+				{"HOME", ""},
+				{"USERPROFILE", "up"},
+			},
+			want: "up",
+		},
+		{
+			name: "none available",
+			envs: []env{
+				{"XDG_CACHE_HOME", ""},
+				{"HOME", ""},
+				{"USERPROFILE", ""},
+			},
+			want: "",
+		},
+	}
+
+	for _, c := range cases {
+		t.Run(c.name, func(tt *testing.T) {
+			var unsets []func()
+			for _, e := range c.envs {
+				unsets = append(unsets, testutil.WithEnvVar(e.k, e.v))
+			}
+
+			got := HomeDir()
+			if got != c.want {
+				t.Errorf("expected:%q got:%q", c.want, got)
+			}
+			for _, u := range unsets {
+				u()
+			}
+		})
+	}
+}
+
+func Test_kubeconfigPath(t *testing.T) {
+	defer testutil.WithEnvVar("HOME", "/x/y/z")()
+
+	expected := filepath.FromSlash("/x/y/z/.kube/config")
+	got, err := kubeconfigPath()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got != expected {
+		t.Fatalf("got=%q expected=%q", got, expected)
+	}
+}
+
+func Test_kubeconfigPath_noEnvVars(t *testing.T) {
+	defer testutil.WithEnvVar("XDG_CACHE_HOME", "")()
+	defer testutil.WithEnvVar("HOME", "")()
+	defer testutil.WithEnvVar("USERPROFILE", "")()
+
+	_, err := kubeconfigPath()
+	if err == nil {
+		t.Fatalf("expected error")
+	}
+}
+
+func Test_kubeconfigPath_envOvveride(t *testing.T) {
+	defer testutil.WithEnvVar("KUBECONFIG", "foo")()
+
+	v, err := kubeconfigPath()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if expected := "foo"; v != expected {
+		t.Fatalf("expected=%q, got=%q", expected, v)
+	}
+}
+
+func Test_kubeconfigPath_envOvverideDoesNotSupportPathSeparator(t *testing.T) {
+	path := strings.Join([]string{"file1", "file2"}, string(os.PathListSeparator))
+	defer testutil.WithEnvVar("KUBECONFIG", path)()
+
+	_, err := kubeconfigPath()
+	if err == nil {
+		t.Fatal("expected error")
+	}
+}
+
+func TestStandardKubeconfigLoader_returnsNotFoundErr(t *testing.T) {
+	defer testutil.WithEnvVar("KUBECONFIG", "foo")()
+	kc := new(kubeconfig.Kubeconfig).WithLoader(DefaultLoader)
+	err := kc.Parse()
+	if err == nil {
+		t.Fatal("expected err")
+	}
+	if !IsNotFoundErr(err) {
+		t.Fatalf("expected ENOENT error; got=%v", err)
+	}
+}
--- a/internal/env/constants.go
+++ b/internal/env/constants.go
@@ -0,0 +1,18 @@
+package env
+
+const (
+	// EnvFZFIgnore describes the environment variable to set to disable
+	// interactive context selection when fzf is installed.
+	EnvFZFIgnore = "KUBECTX_IGNORE_FZF"
+
+	// EnvForceColor describes the environment variable to disable color usage
+	// when printing current context in a list.
+	EnvNoColor = `NO_COLOR`
+
+	// EnvForceColor describes the "internal" environment variable to force
+	// color usage to show current context in a list.
+	EnvForceColor = `_KUBECTX_FORCE_COLOR`
+
+	// EnvDebug describes the internal environment variable for more verbose logging.
+	EnvDebug = `DEBUG`
+)
--- a/internal/kubeconfig/contextmodify.go
+++ b/internal/kubeconfig/contextmodify.go
@@ -0,0 +1,69 @@
+package kubeconfig
+
+import (
+	"github.com/pkg/errors"
+	"gopkg.in/yaml.v3"
+)
+
+func (k *Kubeconfig) DeleteContextEntry(deleteName string) error {
+	contexts, err := k.contextsNode()
+	if err != nil {
+		return err
+	}
+
+	i := -1
+	for j, ctxNode := range contexts.Content {
+		nameNode := valueOf(ctxNode, "name")
+		if nameNode != nil && nameNode.Kind == yaml.ScalarNode && nameNode.Value == deleteName {
+			i = j
+			break
+		}
+	}
+	if i >= 0 {
+		copy(contexts.Content[i:], contexts.Content[i+1:])
+		contexts.Content[len(contexts.Content)-1] = nil
+		contexts.Content = contexts.Content[:len(contexts.Content)-1]
+	}
+	return nil
+}
+
+func (k *Kubeconfig) ModifyCurrentContext(name string) error {
+	currentCtxNode := valueOf(k.rootNode, "current-context")
+	if currentCtxNode != nil {
+		currentCtxNode.Value = name
+		return nil
+	}
+
+	// if current-context field doesn't exist, create new field
+	keyNode := &yaml.Node{
+		Kind:  yaml.ScalarNode,
+		Value: "current-context",
+		Tag:   "!!str"}
+	valueNode := &yaml.Node{
+		Kind:  yaml.ScalarNode,
+		Value: name,
+		Tag:   "!!str"}
+	k.rootNode.Content = append(k.rootNode.Content, keyNode, valueNode)
+	return nil
+}
+
+func (k *Kubeconfig) ModifyContextName(old, new string) error {
+	contexts, err := k.contextsNode()
+	if err != nil {
+		return err
+	}
+
+	var changed bool
+	for _, contextNode := range contexts.Content {
+		nameNode := valueOf(contextNode, "name")
+		if nameNode.Kind == yaml.ScalarNode && nameNode.Value == old {
+			nameNode.Value = new
+			changed = true
+			break
+		}
+	}
+	if !changed {
+		return errors.New("no changes were made")
+	}
+	return nil
+}
--- a/internal/kubeconfig/contextmodify_test.go
+++ b/internal/kubeconfig/contextmodify_test.go
@@ -0,0 +1,166 @@
+package kubeconfig
+
+import (
+	"testing"
+
+	"github.com/google/go-cmp/cmp"
+
+	"github.com/ahmetb/kubectx/internal/testutil"
+)
+
+func TestKubeconfig_DeleteContextEntry_errors(t *testing.T) {
+	kc := new(Kubeconfig).WithLoader(WithMockKubeconfigLoader(`[1, 2, 3]`))
+	_ = kc.Parse()
+	err := kc.DeleteContextEntry("foo")
+	if err == nil {
+		t.Fatal("supposed to fail on non-mapping nodes")
+	}
+
+	kc = new(Kubeconfig).WithLoader(WithMockKubeconfigLoader(`a: b`))
+	_ = kc.Parse()
+	err = kc.DeleteContextEntry("foo")
+	if err == nil {
+		t.Fatal("supposed to fail if contexts key does not exist")
+	}
+
+	kc = new(Kubeconfig).WithLoader(WithMockKubeconfigLoader(`contexts: "some string"`))
+	_ = kc.Parse()
+	err = kc.DeleteContextEntry("foo")
+	if err == nil {
+		t.Fatal("supposed to fail if contexts key is not an array")
+	}
+}
+
+func TestKubeconfig_DeleteContextEntry(t *testing.T) {
+	test := WithMockKubeconfigLoader(
+		testutil.KC().WithCtxs(
+			testutil.Ctx("c1"),
+			testutil.Ctx("c2"),
+			testutil.Ctx("c3")).ToYAML(t))
+	kc := new(Kubeconfig).WithLoader(test)
+	if err := kc.Parse(); err != nil {
+		t.Fatal(err)
+	}
+	if err := kc.DeleteContextEntry("c1"); err != nil {
+		t.Fatal(err)
+	}
+	if err := kc.Save(); err != nil {
+		t.Fatal(err)
+	}
+
+	expected := testutil.KC().WithCtxs(
+		testutil.Ctx("c2"),
+		testutil.Ctx("c3")).ToYAML(t)
+	out := test.Output()
+	if diff := cmp.Diff(expected, out); diff != "" {
+		t.Fatalf("diff: %s", diff)
+	}
+}
+
+func TestKubeconfig_ModifyCurrentContext_fieldExists(t *testing.T) {
+	test := WithMockKubeconfigLoader(
+		testutil.KC().WithCurrentCtx("abc").Set("field1", "value1").ToYAML(t))
+	kc := new(Kubeconfig).WithLoader(test)
+	if err := kc.Parse(); err != nil {
+		t.Fatal(err)
+	}
+	if err := kc.ModifyCurrentContext("foo"); err != nil {
+		t.Fatal(err)
+	}
+	if err := kc.Save(); err != nil {
+		t.Fatal(err)
+	}
+
+	expected := testutil.KC().WithCurrentCtx("foo").Set("field1", "value1").ToYAML(t)
+	out := test.Output()
+	if diff := cmp.Diff(expected, out); diff != "" {
+		t.Fatalf("diff: %s", diff)
+	}
+}
+
+func TestKubeconfig_ModifyCurrentContext_fieldMissing(t *testing.T) {
+	test := WithMockKubeconfigLoader(`f1: v1`)
+	kc := new(Kubeconfig).WithLoader(test)
+	if err := kc.Parse(); err != nil {
+		t.Fatal(err)
+	}
+	if err := kc.ModifyCurrentContext("foo"); err != nil {
+		t.Fatal(err)
+	}
+	if err := kc.Save(); err != nil {
+		t.Fatal(err)
+	}
+
+	expected := `f1: v1
+current-context: foo
+`
+	out := test.Output()
+	if diff := cmp.Diff(expected, out); diff != "" {
+		t.Fatalf("diff: %s", diff)
+	}
+}
+
+func TestKubeconfig_ModifyContextName_noContextsEntryError(t *testing.T) {
+	// no context entries
+	test := WithMockKubeconfigLoader(`a: b`)
+	kc := new(Kubeconfig).WithLoader(test)
+	if err := kc.Parse(); err != nil {
+		t.Fatal(err)
+	}
+	if err := kc.ModifyContextName("c1", "c2"); err == nil {
+		t.Fatal("was expecting error for no 'contexts' entry; got nil")
+	}
+}
+
+func TestKubeconfig_ModifyContextName_contextsEntryNotSequenceError(t *testing.T) {
+	// no context entries
+	test := WithMockKubeconfigLoader(
+		`contexts: "hello"`)
+	kc := new(Kubeconfig).WithLoader(test)
+	if err := kc.Parse(); err != nil {
+		t.Fatal(err)
+	}
+	if err := kc.ModifyContextName("c1", "c2"); err == nil {
+		t.Fatal("was expecting error for 'context entry not a sequence'; got nil")
+	}
+}
+
+func TestKubeconfig_ModifyContextName_noChange(t *testing.T) {
+	test := WithMockKubeconfigLoader(testutil.KC().WithCtxs(
+		testutil.Ctx("c1"),
+		testutil.Ctx("c2"),
+		testutil.Ctx("c3")).ToYAML(t))
+	kc := new(Kubeconfig).WithLoader(test)
+	if err := kc.Parse(); err != nil {
+		t.Fatal(err)
+	}
+	if err := kc.ModifyContextName("c5", "c6"); err == nil {
+		t.Fatal("was expecting error for 'no changes made'")
+	}
+}
+
+func TestKubeconfig_ModifyContextName(t *testing.T) {
+	test := WithMockKubeconfigLoader(testutil.KC().WithCtxs(
+		testutil.Ctx("c1"),
+		testutil.Ctx("c2"),
+		testutil.Ctx("c3")).ToYAML(t))
+	kc := new(Kubeconfig).WithLoader(test)
+	if err := kc.Parse(); err != nil {
+		t.Fatal(err)
+	}
+	if err := kc.ModifyContextName("c1", "ccc"); err != nil {
+		t.Fatal(err)
+	}
+	if err := kc.Save(); err != nil {
+		t.Fatal(err)
+	}
+
+	expected := testutil.KC().WithCtxs(
+		testutil.Ctx("ccc"),
+		testutil.Ctx("c2"),
+		testutil.Ctx("c3")).ToYAML(t)
+	out := test.Output()
+	if diff := cmp.Diff(expected, out); diff != "" {
+		t.Fatalf("diff: %s", diff)
+	}
+}
--- a/internal/kubeconfig/contexts.go
+++ b/internal/kubeconfig/contexts.go
@@ -0,0 +1,72 @@
+package kubeconfig
+
+import (
+	"github.com/pkg/errors"
+	"gopkg.in/yaml.v3"
+)
+
+func (k *Kubeconfig) contextsNode() (*yaml.Node, error) {
+	contexts := valueOf(k.rootNode, "contexts")
+	if contexts == nil {
+		return nil, errors.New("\"contexts\" entry is nil")
+	} else if contexts.Kind != yaml.SequenceNode {
+		return nil, errors.New("\"contexts\" is not a sequence node")
+	}
+	return contexts, nil
+}
+
+func (k *Kubeconfig) contextNode(name string) (*yaml.Node, error) {
+	contexts, err := k.contextsNode()
+	if err != nil {
+		return nil, err
+	}
+
+	for _, contextNode := range contexts.Content {
+		nameNode := valueOf(contextNode, "name")
+		if nameNode.Kind == yaml.ScalarNode && nameNode.Value == name {
+			return contextNode, nil
+		}
+	}
+	return nil, errors.Errorf("context with name %q not found", name)
+}
+
+func (k *Kubeconfig) ContextNames() []string {
+	contexts := valueOf(k.rootNode, "contexts")
+	if contexts == nil {
+		return nil
+	}
+	if contexts.Kind != yaml.SequenceNode {
+		return nil
+	}
+
+	var ctxNames []string
+	for _, ctx := range contexts.Content {
+		nameVal := valueOf(ctx, "name")
+		if nameVal != nil {
+			ctxNames = append(ctxNames, nameVal.Value)
+		}
+	}
+	return ctxNames
+}
+
+func (k *Kubeconfig) ContextExists(name string) bool {
+	ctxNames := k.ContextNames()
+	for _, v := range ctxNames {
+		if v == name {
+			return true
+		}
+	}
+	return false
+}
+
+func valueOf(mapNode *yaml.Node, key string) *yaml.Node {
+	if mapNode.Kind != yaml.MappingNode {
+		return nil
+	}
+	for i, ch := range mapNode.Content {
+		if i%2 == 0 && ch.Kind == yaml.ScalarNode && ch.Value == key {
+			return mapNode.Content[i+1]
+		}
+	}
+	return nil
+}
--- a/internal/kubeconfig/contexts_test.go
+++ b/internal/kubeconfig/contexts_test.go
@@ -0,0 +1,75 @@
+package kubeconfig
+
+import (
+	"testing"
+
+	"github.com/google/go-cmp/cmp"
+
+	"github.com/ahmetb/kubectx/internal/testutil"
+)
+
+func TestKubeconfig_ContextNames(t *testing.T) {
+	tl := WithMockKubeconfigLoader(
+		testutil.KC().WithCtxs(
+			testutil.Ctx("abc"),
+			testutil.Ctx("def"),
+			testutil.Ctx("ghi")).Set("field1", map[string]string{"bar": "zoo"}).ToYAML(t))
+	kc := new(Kubeconfig).WithLoader(tl)
+	if err := kc.Parse(); err != nil {
+		t.Fatal(err)
+	}
+
+	ctx := kc.ContextNames()
+	expected := []string{"abc", "def", "ghi"}
+	if diff := cmp.Diff(expected, ctx); diff != "" {
+		t.Fatalf("%s", diff)
+	}
+}
+
+func TestKubeconfig_ContextNames_noContextsEntry(t *testing.T) {
+	tl := WithMockKubeconfigLoader(`a: b`)
+	kc := new(Kubeconfig).WithLoader(tl)
+	if err := kc.Parse(); err != nil {
+		t.Fatal(err)
+	}
+	ctx := kc.ContextNames()
+	var expected []string = nil
+	if diff := cmp.Diff(expected, ctx); diff != "" {
+		t.Fatalf("%s", diff)
+	}
+}
+
+func TestKubeconfig_ContextNames_nonArrayContextsEntry(t *testing.T) {
+	tl := WithMockKubeconfigLoader(`contexts: "hello"`)
+	kc := new(Kubeconfig).WithLoader(tl)
+	if err := kc.Parse(); err != nil {
+		t.Fatal(err)
+	}
+	ctx := kc.ContextNames()
+	var expected []string = nil
+	if diff := cmp.Diff(expected, ctx); diff != "" {
+		t.Fatalf("%s", diff)
+	}
+}
+
+func TestKubeconfig_CheckContextExists(t *testing.T) {
+	tl := WithMockKubeconfigLoader(
+		testutil.KC().WithCtxs(
+			testutil.Ctx("c1"),
+			testutil.Ctx("c2")).ToYAML(t))
+
+	kc := new(Kubeconfig).WithLoader(tl)
+	if err := kc.Parse(); err != nil {
+		t.Fatal(err)
+	}
+
+	if !kc.ContextExists("c1") {
+		t.Fatal("c1 actually exists; reported false")
+	}
+	if !kc.ContextExists("c2") {
+		t.Fatal("c2 actually exists; reported false")
+	}
+	if kc.ContextExists("c3") {
+		t.Fatal("c3 does not exist; but reported true")
+	}
+}
--- a/internal/kubeconfig/currentcontext.go
+++ b/internal/kubeconfig/currentcontext.go
@@ -0,0 +1,17 @@
+package kubeconfig
+
+// GetCurrentContext returns "current-context" value in given
+// kubeconfig object Node, or returns "" if not found.
+func (k *Kubeconfig) GetCurrentContext() string {
+	v := valueOf(k.rootNode, "current-context")
+	if v == nil {
+		return ""
+	}
+	return v.Value
+}
+
+func (k *Kubeconfig) UnsetCurrentContext() error {
+	curCtxValNode := valueOf(k.rootNode, "current-context")
+	curCtxValNode.Value = ""
+	return nil
+}
--- a/internal/kubeconfig/currentcontext_test.go
+++ b/internal/kubeconfig/currentcontext_test.go
@@ -0,0 +1,55 @@
+package kubeconfig
+
+import (
+	"testing"
+
+	"github.com/ahmetb/kubectx/internal/testutil"
+)
+
+func TestKubeconfig_GetCurrentContext(t *testing.T) {
+	tl := WithMockKubeconfigLoader(`current-context: foo`)
+	kc := new(Kubeconfig).WithLoader(tl)
+	if err := kc.Parse(); err != nil {
+		t.Fatal(err)
+	}
+	v := kc.GetCurrentContext()
+
+	expected := "foo"
+	if v != expected {
+		t.Fatalf("expected=%q; got=%q", expected, v)
+	}
+}
+
+func TestKubeconfig_GetCurrentContext_missingField(t *testing.T) {
+	tl := WithMockKubeconfigLoader(`abc: def`)
+	kc := new(Kubeconfig).WithLoader(tl)
+	if err := kc.Parse(); err != nil {
+		t.Fatal(err)
+	}
+	v := kc.GetCurrentContext()
+
+	expected := ""
+	if v != expected {
+		t.Fatalf("expected=%q; got=%q", expected, v)
+	}
+}
+
+func TestKubeconfig_UnsetCurrentContext(t *testing.T) {
+	tl := WithMockKubeconfigLoader(testutil.KC().WithCurrentCtx("foo").ToYAML(t))
+	kc := new(Kubeconfig).WithLoader(tl)
+	if err := kc.Parse(); err != nil {
+		t.Fatal(err)
+	}
+	if err := kc.UnsetCurrentContext(); err != nil {
+		t.Fatal(err)
+	}
+	if err := kc.Save(); err != nil {
+		t.Fatal(err)
+	}
+
+	out := tl.Output()
+	expected := testutil.KC().WithCurrentCtx("").ToYAML(t)
+	if out != expected {
+		t.Fatalf("expected=%q; got=%q", expected, out)
+	}
+}
--- a/internal/kubeconfig/helper_test.go
+++ b/internal/kubeconfig/helper_test.go
@@ -0,0 +1,23 @@
+package kubeconfig
+
+import (
+	"bytes"
+	"io"
+	"strings"
+)
+
+type MockKubeconfigLoader struct {
+	in  io.Reader
+	out bytes.Buffer
+}
+
+func (t *MockKubeconfigLoader) Read(p []byte) (n int, err error)    { return t.in.Read(p) }
+func (t *MockKubeconfigLoader) Write(p []byte) (n int, err error)   { return t.out.Write(p) }
+func (t *MockKubeconfigLoader) Close() error                        { return nil }
+func (t *MockKubeconfigLoader) Reset() error                        { return nil }
+func (t *MockKubeconfigLoader) Load() (ReadWriteResetCloser, error) { return t, nil }
+func (t *MockKubeconfigLoader) Output() string                      { return t.out.String() }
+
+func WithMockKubeconfigLoader(kubecfg string) *MockKubeconfigLoader {
+	return &MockKubeconfigLoader{in: strings.NewReader(kubecfg)}
+}
--- a/internal/kubeconfig/kubeconfig.go
+++ b/internal/kubeconfig/kubeconfig.go
@@ -0,0 +1,69 @@
+package kubeconfig
+
+import (
+	"io"
+
+	"github.com/pkg/errors"
+	"gopkg.in/yaml.v3"
+)
+
+type ReadWriteResetCloser interface {
+	io.ReadWriteCloser
+
+	// Reset truncates the file and seeks to the beginning of the file.
+	Reset() error
+}
+
+type Loader interface {
+	Load() (ReadWriteResetCloser, error)
+}
+
+type Kubeconfig struct {
+	loader Loader
+
+	f        ReadWriteResetCloser
+	rootNode *yaml.Node
+}
+
+func (k *Kubeconfig) WithLoader(l Loader) *Kubeconfig {
+	k.loader = l
+	return k
+}
+
+func (k *Kubeconfig) Close() error {
+	if k.f == nil {
+		return nil
+	}
+	return k.f.Close()
+}
+
+func (k *Kubeconfig) Parse() error {
+	f, err := k.loader.Load()
+	if err != nil {
+		return errors.Wrap(err, "failed to load")
+	}
+
+	k.f = f
+	var v yaml.Node
+	if err := yaml.NewDecoder(f).Decode(&v); err != nil {
+		return errors.Wrap(err, "failed to decode")
+	}
+	k.rootNode = v.Content[0]
+	if k.rootNode.Kind != yaml.MappingNode {
+		return errors.New("kubeconfig file is not a map document")
+	}
+	return nil
+}
+
+func (k *Kubeconfig) Bytes() ([]byte, error) {
+	return yaml.Marshal(k.rootNode)
+}
+
+func (k *Kubeconfig) Save() error {
+	if err := k.f.Reset(); err != nil {
+		return errors.Wrap(err, "failed to reset file")
+	}
+	enc := yaml.NewEncoder(k.f)
+	enc.SetIndent(0)
+	return enc.Encode(k.rootNode)
+}
--- a/internal/kubeconfig/kubeconfig_test.go
+++ b/internal/kubeconfig/kubeconfig_test.go
@@ -0,0 +1,53 @@
+package kubeconfig
+
+import (
+	"testing"
+
+	"github.com/google/go-cmp/cmp"
+
+	"github.com/ahmetb/kubectx/internal/testutil"
+)
+
+func TestParse(t *testing.T) {
+	err := new(Kubeconfig).WithLoader(WithMockKubeconfigLoader(`a: [1, 2`)).Parse()
+	if err == nil {
+		t.Fatal("expected error from bad yaml")
+	}
+
+	err = new(Kubeconfig).WithLoader(WithMockKubeconfigLoader(`[1, 2, 3]`)).Parse()
+	if err == nil {
+		t.Fatal("expected error from not-mapping root node")
+	}
+
+	err = new(Kubeconfig).WithLoader(WithMockKubeconfigLoader(`current-context: foo`)).Parse()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = new(Kubeconfig).WithLoader(WithMockKubeconfigLoader(testutil.KC().
+		WithCurrentCtx("foo").
+		WithCtxs().ToYAML(t))).Parse()
+	if err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestSave(t *testing.T) {
+	in := "a: [1, 2, 3]\n"
+	test := WithMockKubeconfigLoader(in)
+	kc := new(Kubeconfig).WithLoader(test)
+	defer kc.Close()
+	if err := kc.Parse(); err != nil {
+		t.Fatal(err)
+	}
+	if err := kc.ModifyCurrentContext("hello"); err != nil {
+		t.Fatal(err)
+	}
+	if err := kc.Save(); err != nil {
+		t.Fatal(err)
+	}
+	expected := "a: [1, 2, 3]\ncurrent-context: hello\n"
+	if diff := cmp.Diff(expected, test.Output()); diff != "" {
+		t.Fatal(diff)
+	}
+}
--- a/internal/kubeconfig/namespace.go
+++ b/internal/kubeconfig/namespace.go
@@ -0,0 +1,63 @@
+package kubeconfig
+
+import "gopkg.in/yaml.v3"
+
+const (
+	defaultNamespace = "default"
+)
+
+func (k *Kubeconfig) NamespaceOfContext(contextName string) (string, error) {
+	ctx, err := k.contextNode(contextName)
+	if err != nil {
+		return "", err
+	}
+	ctxBody := valueOf(ctx, "context")
+	if ctxBody == nil {
+		return defaultNamespace, nil
+	}
+	ns := valueOf(ctxBody, "namespace")
+	if ns == nil || ns.Value == "" {
+		return defaultNamespace, nil
+	}
+	return ns.Value, nil
+}
+
+func (k *Kubeconfig) SetNamespace(ctxName string, ns string) error {
+	ctxNode, err := k.contextNode(ctxName)
+	if err != nil {
+		return err
+	}
+
+	var ctxBodyNodeWasEmpty bool // actual namespace value is in contexts[index].context.namespace, but .context might not exist
+	ctxBodyNode := valueOf(ctxNode, "context")
+	if ctxBodyNode == nil {
+		ctxBodyNodeWasEmpty = true
+		ctxBodyNode = &yaml.Node{
+			Kind: yaml.MappingNode,
+		}
+	}
+
+	nsNode := valueOf(ctxBodyNode, "namespace")
+	if nsNode != nil {
+		nsNode.Value = ns
+		return nil
+	}
+
+	keyNode := &yaml.Node{
+		Kind:  yaml.ScalarNode,
+		Value: "namespace",
+		Tag:   "!!str"}
+	valueNode := &yaml.Node{
+		Kind:  yaml.ScalarNode,
+		Value: ns,
+		Tag:   "!!str"}
+	ctxBodyNode.Content = append(ctxBodyNode.Content, keyNode, valueNode)
+	if ctxBodyNodeWasEmpty {
+		ctxNode.Content = append(ctxNode.Content, &yaml.Node{
+			Kind:  yaml.ScalarNode,
+			Value: "context",
+			Tag:   "!!str",
+		}, ctxBodyNode)
+	}
+	return nil
+}
--- a/internal/kubeconfig/namespace_test.go
+++ b/internal/kubeconfig/namespace_test.go
@@ -0,0 +1,80 @@
+package kubeconfig
+
+import (
+	"testing"
+
+	"github.com/google/go-cmp/cmp"
+
+	"github.com/ahmetb/kubectx/internal/testutil"
+)
+
+func TestKubeconfig_NamespaceOfContext_ctxNotFound(t *testing.T) {
+	kc := new(Kubeconfig).WithLoader(WithMockKubeconfigLoader(testutil.KC().
+		WithCtxs(testutil.Ctx("c1")).ToYAML(t)))
+	if err := kc.Parse(); err != nil {
+		t.Fatal(err)
+	}
+
+	_, err := kc.NamespaceOfContext("c2")
+	if err == nil {
+		t.Fatal("expected err")
+	}
+}
+
+func TestKubeconfig_NamespaceOfContext(t *testing.T) {
+	kc := new(Kubeconfig).WithLoader(WithMockKubeconfigLoader(testutil.KC().
+		WithCtxs(
+			testutil.Ctx("c1"),
+			testutil.Ctx("c2").Ns("c2n1")).ToYAML(t)))
+	if err := kc.Parse(); err != nil {
+		t.Fatal(err)
+	}
+
+	v1, err := kc.NamespaceOfContext("c1")
+	if err != nil {
+		t.Fatal("expected err")
+	}
+	if expected := `default`; v1 != expected {
+		t.Fatalf("c1: expected=%q got=%q", expected, v1)
+	}
+
+	v2, err := kc.NamespaceOfContext("c2")
+	if err != nil {
+		t.Fatal("expected err")
+	}
+	if expected := `c2n1`; v2 != expected {
+		t.Fatalf("c2: expected=%q got=%q", expected, v2)
+	}
+}
+
+func TestKubeconfig_SetNamespace(t *testing.T) {
+	l := WithMockKubeconfigLoader(testutil.KC().
+		WithCtxs(
+			testutil.Ctx("c1"),
+			testutil.Ctx("c2").Ns("c2n1")).ToYAML(t))
+	kc := new(Kubeconfig).WithLoader(l)
+	if err := kc.Parse(); err != nil {
+		t.Fatal(err)
+	}
+
+	if err := kc.SetNamespace("c3", "foo"); err == nil {
+		t.Fatalf("expected error for non-existing ctx")
+	}
+
+	if err := kc.SetNamespace("c1", "c1n1"); err != nil {
+		t.Fatal(err)
+	}
+	if err := kc.SetNamespace("c2", "c2n2"); err != nil {
+		t.Fatal(err)
+	}
+	if err := kc.Save(); err != nil {
+		t.Fatal(err)
+	}
+
+	expected := testutil.KC().WithCtxs(
+		testutil.Ctx("c1").Ns("c1n1"),
+		testutil.Ctx("c2").Ns("c2n2")).ToYAML(t)
+	if diff := cmp.Diff(l.Output(), expected); diff != "" {
+		t.Fatal(diff)
+	}
+}
--- a/internal/printer/color.go
+++ b/internal/printer/color.go
@@ -0,0 +1,40 @@
+package printer
+
+import (
+	"os"
+
+	"github.com/fatih/color"
+
+	"github.com/ahmetb/kubectx/internal/env"
+)
+
+var (
+	ActiveItemColor = color.New(color.FgGreen, color.Bold)
+)
+
+func init(){
+	EnableOrDisableColor(ActiveItemColor)
+}
+
+// useColors returns true if colors are force-enabled,
+// false if colors are disabled, or nil for default behavior
+// which is determined based on factors like if stdout is tty.
+func useColors() *bool {
+	tr, fa := true, false
+	if os.Getenv(env.EnvForceColor) != "" {
+		return &tr
+	} else if os.Getenv(env.EnvNoColor) != "" {
+		return &fa
+	}
+	return nil
+}
+
+// EnableOrDisableColor determines if color should be force-enabled or force-disabled
+// or left untouched based on environment configuration.
+func EnableOrDisableColor(c *color.Color) {
+	if v := useColors(); v != nil && *v {
+		c.EnableColor()
+	} else if v != nil && !*v {
+		c.DisableColor()
+	}
+}
--- a/internal/printer/color_test.go
+++ b/internal/printer/color_test.go
@@ -0,0 +1,39 @@
+package printer
+
+import (
+	"testing"
+
+	"github.com/google/go-cmp/cmp"
+
+	"github.com/ahmetb/kubectx/internal/testutil"
+)
+
+var (
+	tr, fa = true, false
+)
+
+func Test_useColors_forceColors(t *testing.T) {
+	defer testutil.WithEnvVar("_KUBECTX_FORCE_COLOR", "1")()
+	defer testutil.WithEnvVar("NO_COLOR", "1")()
+
+	if v := useColors(); !cmp.Equal(v, &tr) {
+		t.Fatalf("expected useColors() = true; got = %v", v)
+	}
+}
+
+func Test_useColors_disableColors(t *testing.T) {
+	defer testutil.WithEnvVar("NO_COLOR", "1")()
+
+	if v := useColors(); !cmp.Equal(v, &fa) {
+		t.Fatalf("expected useColors() = false; got = %v", v)
+	}
+}
+
+func Test_useColors_default(t *testing.T) {
+	defer testutil.WithEnvVar("NO_COLOR", "")()
+	defer testutil.WithEnvVar("_KUBECTX_FORCE_COLOR", "")()
+
+	if v := useColors(); v != nil {
+		t.Fatalf("expected useColors() = nil; got=%v", *v)
+	}
+}
--- a/internal/printer/printer.go
+++ b/internal/printer/printer.go
@@ -0,0 +1,45 @@
+package printer
+
+import (
+	"fmt"
+	"io"
+
+	"github.com/fatih/color"
+)
+
+var (
+	ErrorColor   = color.New(color.FgRed, color.Bold)
+	WarningColor = color.New(color.FgYellow, color.Bold)
+	SuccessColor = color.New(color.FgGreen)
+)
+
+func init() {
+	colors := useColors()
+	if colors == nil {
+		return
+	}
+	if *colors {
+		ErrorColor.EnableColor()
+		WarningColor.EnableColor()
+		SuccessColor.EnableColor()
+	} else {
+		ErrorColor.DisableColor()
+		WarningColor.DisableColor()
+		SuccessColor.DisableColor()
+	}
+}
+
+func Error(w io.Writer, format string, args ...interface{}) error {
+	_, err := fmt.Fprintf(w, ErrorColor.Sprint("error: ")+format+"\n", args...)
+	return err
+}
+
+func Warning(w io.Writer, format string, args ...interface{}) error {
+	_, err := fmt.Fprintf(w, WarningColor.Sprint("warning: ")+format+"\n", args...)
+	return err
+}
+
+func Success(w io.Writer, format string, args ...interface{}) error {
+	_, err := fmt.Fprintf(w, SuccessColor.Sprint("✔ ")+fmt.Sprintf(format+"\n", args...))
+	return err
+}
--- a/internal/testutil/kubeconfigbuilder.go
+++ b/internal/testutil/kubeconfigbuilder.go
@@ -0,0 +1,39 @@
+package testutil
+
+import (
+	"strings"
+	"testing"
+
+	"gopkg.in/yaml.v3"
+)
+
+type Context struct {
+	Name    string `yaml:"name,omitempty"`
+	Context struct {
+		Namespace string `yaml:"namespace,omitempty"`
+	} `yaml:"context,omitempty"`
+}
+
+func Ctx(name string) *Context           { return &Context{Name: name} }
+func (c *Context) Ns(ns string) *Context { c.Context.Namespace = ns; return c }
+
+type Kubeconfig map[string]interface{}
+
+func KC() *Kubeconfig {
+	return &Kubeconfig{
+		"apiVersion": "v1",
+		"kind":       "Config"}
+}
+
+func (k *Kubeconfig) Set(key string, v interface{}) *Kubeconfig { (*k)[key] = v; return k }
+func (k *Kubeconfig) WithCurrentCtx(s string) *Kubeconfig       { (*k)["current-context"] = s; return k }
+func (k *Kubeconfig) WithCtxs(c ...*Context) *Kubeconfig        { (*k)["contexts"] = c; return k }
+
+func (k *Kubeconfig) ToYAML(t *testing.T) string {
+	t.Helper()
+	var v strings.Builder
+	if err := yaml.NewEncoder(&v).Encode(*k); err != nil {
+		t.Fatalf("failed to encode mock kubeconfig: %v", err)
+	}
+	return v.String()
+}
--- a/internal/testutil/tempfile.go
+++ b/internal/testutil/tempfile.go
@@ -0,0 +1,26 @@
+package testutil
+
+import (
+	"io/ioutil"
+	"os"
+	"testing"
+)
+
+func TempFile(t *testing.T, contents string) (path string, cleanup func()) {
+	// TODO consider removing, used only in one place.
+	t.Helper()
+
+	f, err := ioutil.TempFile(os.TempDir(), "test-file")
+	if err != nil {
+		t.Fatalf("failed to create test file: %v", err)
+	}
+	path = f.Name()
+	if _, err := f.Write([]byte(contents)); err != nil {
+		t.Fatalf("failed to write to test file: %v", err)
+	}
+
+	return path, func() {
+		f.Close()
+		os.Remove(path)
+	}
+}
--- a/internal/testutil/testutil.go
+++ b/internal/testutil/testutil.go
@@ -0,0 +1,17 @@
+package testutil
+
+import "os"
+
+// WithEnvVar sets an env var temporarily. Call its return value
+// in defer to restore original value in env (if exists).
+func WithEnvVar(key, value string) func() {
+	orig, ok := os.LookupEnv(key)
+	os.Setenv(key, value)
+	return func() {
+		if ok {
+			os.Setenv(key, orig)
+		} else {
+			os.Unsetenv(key)
+		}
+	}
+}
--- a/test/kubectx.bats
+++ b/test/kubectx.bats
@@ -1,19 +1,9 @@
 #!/usr/bin/env bats

-COMMAND="$BATS_TEST_DIRNAME/../kubectx"
+COMMAND="${COMMAND:-$BATS_TEST_DIRNAME/../kubectx}"

 load common

-@test "no kubectl detected" {
-  OLDPATH="$PATH"
-  PATH=/bin
-  run ${COMMAND}
-  echo "$output"
-  [ "$status" -eq 1 ]
-  [[ "$output" = "kubectl is not installed" ]]
-  PATH="$OLDPATH"
-}
-
@test "--help should not fail" {
  run ${COMMAND} --help
  echo "$output"
@@ -32,14 +22,14 @@ load common
  run ${COMMAND} -
  echo "$output"
  [ "$status" -eq 1 ]
-  [[ "$output" = "error: No previous context found." ]]
+  [[ $output = *"no previous context found" ]]
 }

@test "list contexts when no kubeconfig exists" {
  run ${COMMAND}
  echo "$output"
  [ "$status" -eq 0 ]
-  [[ "$output" = "" ]]
+  [[ "$output" = "warning: kubeconfig file not found" ]]
 }

@test "get one context and list contexts" {
--- a/test/kubens.bats
+++ b/test/kubens.bats
@@ -1,8 +1,13 @@
 #!/usr/bin/env bats

-COMMAND="${BATS_TEST_DIRNAME}/../kubens"
+COMMAND="${COMMAND:-$BATS_TEST_DIRNAME/../kubens}"
+
+# TODO(ahmetb) remove this after bash implementations are deleted
 export KUBECTL="$BATS_TEST_DIRNAME/../test/mock-kubectl"

+# short-circuit namespace querying in kubens go implementation
+export _MOCK_NAMESPACES=1
+
 load common

@test "--help should not fail" {
@@ -21,7 +26,6 @@ load common
  run ${COMMAND}
  echo "$output"
  [[ "$status" -eq 1 ]]
-  [[ "$output" = *"current-context is not set"* ]]
 }

@test "list namespaces" {
Author	SHA1	Message	Date
Ahmet Alp Balkan	b51befee82	kubens add a short-circuit to bypass API call for tests Signed-off-by: Ahmet Alp Balkan <ahmetb@google.com>	2020-04-29 12:52:08 -07:00
Ahmet Alp Balkan	be3e5b2d61	ns list: increase page size to 500 Signed-off-by: Ahmet Alp Balkan <ahmetb@google.com>	2020-04-29 12:43:07 -07:00
Ahmet Alp Balkan	cf41febf16	Load namespaces using client-go Signed-off-by: Ahmet Alp Balkan <ahmetb@google.com>	2020-04-29 12:35:27 -07:00
Ahmet Alp Balkan	27a902174f	fix compile error Signed-off-by: Ahmet Alp Balkan <ahmetb@google.com>	2020-04-29 12:16:26 -07:00
Ahmet Alp Balkan	84676b7062	deprecation msgs for KUBECTX_CURRENT_{BG,FG}COLOR Signed-off-by: Ahmet Alp Balkan <ahmetb@google.com>	2020-04-29 12:11:59 -07:00
Ahmet Alp Balkan	64e5a0ed13	Add interactive switching to kubens Signed-off-by: Ahmet Alp Balkan <ahmetb@google.com>	2020-04-29 11:55:28 -07:00
Ahmet Alp Balkan	ebfd724d08	Fix bug about where cur ns was stored in yaml Signed-off-by: Ahmet Alp Balkan <ahmetb@google.com>	2020-04-18 16:17:47 -07:00
Ahmet Alp Balkan	25833eaa29	kubens: implement namespace switching Signed-off-by: Ahmet Alp Balkan <ahmetb@google.com>	2020-04-18 16:10:34 -07:00
Ahmet Alp Balkan	99b593be90	kubens: Add facility to store state file Signed-off-by: Ahmet Alp Balkan <ahmetb@google.com>	2020-04-18 14:26:38 -07:00
Ahmet Alp Balkan	d0c352c5bf	Implement list (via exec kubectl), clearer color settings Signed-off-by: Ahmet Alp Balkan <ahmetb@google.com>	2020-04-18 14:05:32 -07:00
Ahmet Alp Balkan	3e34177cb9	Move kubeconfig loader utils to cmdutil pkg Signed-off-by: Ahmet Alp Balkan <ahmetb@google.com>	2020-04-18 13:32:53 -07:00
Ahmet Alp Balkan	d4112ce088	kubens: Start implementing stubs Signed-off-by: Ahmet Alp Balkan <ahmetb@google.com>	2020-04-18 13:09:59 -07:00
Ahmet Alp Balkan	56f3370d36	Create test utils for crafting kubeconfig strings Signed-off-by: Ahmet Alp Balkan <ahmetb@google.com>	2020-04-16 21:37:29 -07:00
Ahmet Alp Balkan	7b96a338a3	extract kubeconfig test utils to a type Signed-off-by: Ahmet Alp Balkan <ahmetb@google.com>	2020-04-16 21:00:00 -07:00
Ahmet Alp Balkan	49539fbcb3	do not fail on non-existing kubeconfig files Signed-off-by: Ahmet Alp Balkan <ahmetb@google.com>	2020-04-16 19:55:34 -07:00
Ahmet Alp Balkan	10f53bb15b	Better success msgs, handle -d without args Signed-off-by: Ahmet Alp Balkan <ahmetb@google.com>	2020-04-12 23:06:17 -07:00
Ahmet Alp Balkan	0ebccceeab	Tidy up colors, help msgs, TODOs Signed-off-by: Ahmet Alp Balkan <ahmetb@google.com>	2020-04-12 23:05:22 -07:00
Ahmet Alp Balkan	57f2bb1eb4	Create printer pkg, fix color force enable/disable Signed-off-by: Ahmet Alp Balkan <ahmetb@google.com>	2020-04-12 22:30:10 -07:00
Ahmet Alp Balkan	0ab135af99	Move kubeconfig utility to a shared pkg Signed-off-by: Ahmet Alp Balkan <ahmetb@google.com>	2020-04-12 18:19:38 -07:00
Ahmet Alp Balkan	73c1f268ee	Extend test coverage Signed-off-by: Ahmet Alp Balkan <ahmetb@google.com>	2020-04-12 18:17:03 -07:00
Ahmet Alp Balkan	562631ad2b	Fix UnsupportedOp tests through custom comparer Signed-off-by: Ahmet Alp Balkan <ahmetb@google.com>	2020-04-12 18:03:06 -07:00
Ahmet Alp Balkan	077d8a829d	Re-introduce DEBUG env var stack traces Signed-off-by: Ahmet Alp Balkan <ahmetb@google.com>	2020-04-12 17:57:57 -07:00
Ahmet Alp Balkan	195e6315da	Update tests for homeDir and kubeconfigPath() Signed-off-by: Ahmet Alp Balkan <ahmetb@google.com>	2020-04-12 17:53:09 -07:00
Ahmet Alp Balkan	e5a09017d0	Unify errors from kubeconfig.Parse Signed-off-by: Ahmet Alp Balkan <ahmetb@google.com>	2020-04-12 16:20:34 -07:00
Ahmet Alp Balkan	37ba52f357	Extract env vars to a file + test Signed-off-by: Ahmet Alp Balkan <ahmetb@google.com>	2020-04-12 16:15:17 -07:00
Ahmet Alp Balkan	91e00f9867	Support for fzf, color ignore/force knobs Signed-off-by: Ahmet Alp Balkan <ahmetb@google.com>	2020-04-12 15:59:48 -07:00
Ahmet Alp Balkan	17f6ffe73b	Move all yaml logic to pkg/kubeconfig Signed-off-by: Ahmet Alp Balkan <ahmetb@google.com>	2020-04-12 14:22:52 -07:00
Ahmet Alp Balkan	fb5e8bc904	Move ctx-related YAML parse methods to pkg Signed-off-by: Ahmet Alp Balkan <ahmetb@google.com>	2020-04-12 13:46:14 -07:00
Ahmet Alp Balkan	1313d98f57	Use kubeconfig pkg for parsing utils Signed-off-by: Ahmet Alp Balkan <ahmetb@google.com>	2020-04-12 13:17:08 -07:00
Ahmet Alp Balkan	94664bcaf9	kubeconfig pkg for loading/parsing Signed-off-by: Ahmet Alp Balkan <ahmetb@google.com>	2020-04-12 12:59:20 -07:00
Ahmet Alp Balkan	21d0a6aeeb	add printSuccess, pass writers to print funcs Signed-off-by: Ahmet Alp Balkan <ahmetb@google.com>	2020-04-12 12:37:04 -07:00
Ahmet Alp Balkan	7c2cf62cf0	define Run(stdout,stderr) method on **Ops Signed-off-by: Ahmet Alp Balkan <ahmetb@google.com>	2020-04-12 12:29:08 -07:00
Ahmet Alp Balkan	68ea776826	add some TODOs Signed-off-by: Ahmet Alp Balkan <ahmetb@google.com>	2020-04-10 16:41:21 -07:00
Ahmet Alp Balkan	37441b648f	Fix bugs for test pass, update tests Signed-off-by: Ahmet Alp Balkan <ahmetb@google.com>	2020-04-10 16:23:23 -07:00
Ahmet Alp Balkan	8ce95d4a00	Add support for renaming contexts Signed-off-by: Ahmet Alp Balkan <ahmetb@google.com>	2020-04-10 16:11:38 -07:00
Ahmet Alp Balkan	5ec2f4f032	Support for -d (deleting contexts) Signed-off-by: Ahmet Alp Balkan <ahmetb@google.com>	2020-04-10 15:38:50 -07:00
Ahmet Alp Balkan	32d65fc527	Add support for -u/--unset Signed-off-by: Ahmet Alp Balkan <ahmetb@google.com>	2020-04-10 15:04:31 -07:00
Ahmet Alp Balkan	c5696a46b7	Add support for -c/--current Signed-off-by: Ahmet Alp Balkan <ahmetb@google.com>	2020-04-10 14:50:14 -07:00
Ahmet Alp Balkan	5f40b12a4e	Integrate ctx swap, check for wrong ctx names Signed-off-by: Ahmet Alp Balkan <ahmetb@google.com>	2020-04-10 14:41:57 -07:00
Ahmet Alp Balkan	74a30a60e0	Save last context name in state file Signed-off-by: Ahmet Alp Balkan <ahmetb@google.com>	2020-04-10 14:27:52 -07:00
Ahmet Alp Balkan	7a40a5ed07	Add utils for r/w ~/.kube/kubectx file Signed-off-by: Ahmet Alp Balkan <ahmetb@google.com>	2020-04-10 14:25:00 -07:00
Ahmet Alp Balkan	a9476f3215	Implement switch via editing yaml in-place Signed-off-by: Ahmet Alp Balkan <ahmetb@google.com>	2020-04-10 14:07:12 -07:00
Ahmet Alp Balkan	04e963c02c	Implement context listing Signed-off-by: Ahmet Alp Balkan <ahmetb@google.com>	2020-04-10 13:21:52 -07:00
Ahmet Alp Balkan	da08491f0b	Implement facilities to parse kubeconfig file Signed-off-by: Ahmet Alp Balkan <ahmetb@google.com>	2020-04-10 13:02:00 -07:00
Ahmet Alp Balkan	7c2f8ffa75	Add logic to determine kubeconfig path Signed-off-by: Ahmet Alp Balkan <ahmetb@google.com>	2020-04-10 12:34:31 -07:00
Ahmet Alp Balkan	d2267aa60c	Support help op, add color to error Signed-off-by: Ahmet Alp Balkan <ahmetb@google.com>	2020-04-10 12:07:58 -07:00
Ahmet Alp Balkan	1b2fc5961a	Handle supported operation in main Signed-off-by: Ahmet Alp Balkan <ahmetb@google.com>	2020-04-10 12:00:12 -07:00
Ahmet Alp Balkan	68a8276146	Start porting to Go: parse flags Parse help/list/swap command line flags. Signed-off-by: Ahmet Alp Balkan <ahmetb@google.com>	2020-04-10 11:54:01 -07:00